Правильно ли будет заменить все простые значения константами, в большом пректе?

242

29 августа 2018, 14:40

К примеру, вместо 0 везде писать MyConst0 и т.д. Правильно в плане производительности и стабильности.

        Matrix4 r0, r1, r2, r3;
        f32 a, det, invDet;
        f32* mat = reinterpret_cast<f32 *>(this);
        det = mat[0*4+0] * mat[1*4+1] - mat[0*4+1] * mat[1*4+0];
        if ( std::abs( det ) < 1e-14 ) {
            return false;
        }
        v4f dd;
        invDet = 1.0f / det;
        r0[0][0] =   mat[1*4+1] * invDet;
        r0[0][1] = - mat[0*4+1] * invDet;
        r0[1][0] = - mat[1*4+0] * invDet;
        r0[1][1] =   mat[0*4+0] * invDet;
        r1[0][0] = r0[0][0] * mat[0*4+2] + r0[0][1] * mat[1*4+2];
        r1[0][1] = r0[0][0] * mat[0*4+3] + r0[0][1] * mat[1*4+3];
        r1[1][0] = r0[1][0] * mat[0*4+2] + r0[1][1] * mat[1*4+2];
        r1[1][1] = r0[1][0] * mat[0*4+3] + r0[1][1] * mat[1*4+3];
        r2[0][0] = mat[2*4+0] * r1[0][0] + mat[2*4+1] * r1[1][0];
        r2[0][1] = mat[2*4+0] * r1[0][1] + mat[2*4+1] * r1[1][1];
        r2[1][0] = mat[3*4+0] * r1[0][0] + mat[3*4+1] * r1[1][0];
        r2[1][1] = mat[3*4+0] * r1[0][1] + mat[3*4+1] * r1[1][1];
        r3[0][0] = r2[0][0] - mat[2*4+2];
        r3[0][1] = r2[0][1] - mat[2*4+3];
        r3[1][0] = r2[1][0] - mat[3*4+2];
        r3[1][1] = r2[1][1] - mat[3*4+3];
        det = r3[0][0] * r3[1][1] - r3[0][1] * r3[1][0];
        if ( std::abs( det ) < 1e-14 ) {
            return false;
        }
        invDet = 1.0f / det;
        a = r3[0][0];
        r3[0][0] =   r3[1][1] * invDet;
        r3[0][1] = - r3[0][1] * invDet;
        r3[1][0] = - r3[1][0] * invDet;
        r3[1][1] =   a * invDet;
        r2[0][0] = mat[2*4+0] * r0[0][0] + mat[2*4+1] * r0[1][0];
        r2[0][1] = mat[2*4+0] * r0[0][1] + mat[2*4+1] * r0[1][1];
        r2[1][0] = mat[3*4+0] * r0[0][0] + mat[3*4+1] * r0[1][0];
        r2[1][1] = mat[3*4+0] * r0[0][1] + mat[3*4+1] * r0[1][1];
        mat[2*4+0] = r3[0][0] * r2[0][0] + r3[0][1] * r2[1][0];
        mat[2*4+1] = r3[0][0] * r2[0][1] + r3[0][1] * r2[1][1];
        mat[3*4+0] = r3[1][0] * r2[0][0] + r3[1][1] * r2[1][0];
        mat[3*4+1] = r3[1][0] * r2[0][1] + r3[1][1] * r2[1][1];
        mat[0*4+0] = r0[0][0] - r1[0][0] * mat[2*4+0] - r1[0][1] * mat[3*4+0];
        mat[0*4+1] = r0[0][1] - r1[0][0] * mat[2*4+1] - r1[0][1] * mat[3*4+1];
        mat[1*4+0] = r0[1][0] - r1[1][0] * mat[2*4+0] - r1[1][1] * mat[3*4+0];
        mat[1*4+1] = r0[1][1] - r1[1][0] * mat[2*4+1] - r1[1][1] * mat[3*4+1];
        mat[0*4+2] = r1[0][0] * r3[0][0] + r1[0][1] * r3[1][0];
        mat[0*4+3] = r1[0][0] * r3[0][1] + r1[0][1] * r3[1][1];
        mat[1*4+2] = r1[1][0] * r3[0][0] + r1[1][1] * r3[1][0];
        mat[1*4+3] = r1[1][0] * r3[0][1] + r1[1][1] * r3[1][1];
        mat[2*4+2] = -r3[0][0];
        mat[2*4+3] = -r3[0][1];
        mat[3*4+2] = -r3[1][0];
        mat[3*4+3] = -r3[1][1];

Answer 1

Заводить именованную константу для какого-либо значения имеет смысл лишь в том случае, если допускается вариант в дальнейшем изменять это значение. Таким образом это позволит поменять его в одном месте, где определяется величина, а все остальные места уже подхватятся автоматически.

Если же такой ситуации не наблюдается, т.е. используются вычисления для какого-то одного фиксированного случая, то замена числовых литералов на константы не даст никакого выигрыша, а может быть даже и ухудшить читабельность.

Например, в вашем случае, можно было бы вынести константу const eps = 1e-14;, а индексы оставить как есть.

Заводить же вместо 0 переменную MyConst0 не имеет вообще никакого смысла. Имя должно отражать в первую очередь суть, а не значение, которое хранится внутри. Будет странно потом изменить значение на, скажем, 1 и оставить при этом старое имя.

Answer 2

Да, всегда следует использовать именованные константы вместо литералов для объявления особых значений. Это позволит избежать многих ошибок копирования при использовании этих значений, упростит вызов некоторых методов, улучшит читабельность и поддерживаемость кода.

Однако ключевое слово здесь - особых. Например в вашем случае нет никакого смысла делать 0, 1, 2, 3, и т.п. константами, так как эти значения не несут в себе никакого особого смысла. Это просто элементы ряда положительных чисел. Названия вроде MyConst0 явно говорят о том, что значения ничем не выделяются и вы не получите никаких из перечисленных выше выгод, а сами эти значения у вас накопипасчены просто из-за отсутствия надлежащих методов (для подсчета определителя, для получения размеров матрицы, для итерации / копирования матрицы и т.п.).

Контрпример: константа вроде MyConst0 вполне могла бы иметь смысл если бы ее тип был классом-оберткой. Тогда с ее помощью было бы удобно инициализировать переменные этого класса с выводом типа или было бы проще вызывать перегруженные функции.

ПОСЛЕДНИЕ ВОПРОСЫ

Все вопросы

ТОП-10

Все популярные вопросы

Как создать png текстуру с ресурса в direcx9 приложении и как правильно создать ресурс? directx9

Хочу в directx9 приложении использовать текстуру с png файла который должен "лежать" в ресурсахСобственно наверное нужно использовать D3DXCreateTextureFromResource,...

260

c++