Собственно немного флеймовая тема, но тем не менее. Есть два диаметральных подхода к комментариям
1) Комментируем все, что можно
2) Пишем код так, чтобы комментарии были не нужны . Ну или самый необходимый минимум
Есть ли у вас требования на работе к комментариям, и если есть то какие ?
02.04.11 13:19: Перенесено из 'C/C++'
09.04.11 01:33: Перенесено модератором из 'Священные войны' — AndrewVK
Здравствуйте, alexey_sz, Вы писали:
_>Собственно немного флеймовая тема, но тем не менее. Есть два диаметральных подхода к комментариям _>1) Комментируем все, что можно _>2) Пишем код так, чтобы комментарии были не нужны . Ну или самый необходимый минимум _>Есть ли у вас требования на работе к комментариям, и если есть то какие ?
Это 2 крайности, бросаться в которые глупо.
Глупо писать комментарии на каждый чих, так же глупо не писать их вовсе, да хоть какой бы там у вас читаемый код не был.
Комментарии должны быть написаны человеком, человеческим языком, для человека. Цель комментария — прояснить какие то детали читающему.
Как он будет эту цель достигать всё равно. Хоть "по фене" пиши если это поможет раскрыть тему и донести до читателя самою суть.
Вот как то так.
не всегда но часто если пишеш комментарий (код необычный)
значит написал говнокод можно подумать как переписать
прозрачно без частей требующий комментарий
коментировать нужно не что код делает, а ПОЧЕМУ он это делает.
что делает код есть в нем самом, а почему — есть только в говах авторов
как пример:
у нас в софтину встроен бэкап\рестор базы. При ресторе файл бэкапа, который выбрал пользователь, сначала копируется в temp. Это сделано потому что файл может находиться на терминалке или на замаэпленом сетевом диске, которые сиквел-сервер не видит конечно же. Это не очевидно, и без коментариев кажется что код делает какие-то ненужные бестолковые операции.
Требования например у нас такие комментрии в doxygen, так как генериться портал с документацией, иногда помогает.
Используется стиль с++, т.е. никаких /* */.
> у нас в софтину встроен бэкап\рестор базы. сначала копируется в temp. Это сделано потому что файл может находиться на терминалке или на замаэпленом сетевом диске, которые сиквел-сервер не видит конечно же. Это не очевидно
А если бы код был нормальный, в нем бы проверялось — находится ли файл на терминалке или на замепленном диске и если не находится, то
1) лишних операций бы не выполнялось
2) было бы из кода понятно, почему эти операции нужны
Здравствуйте, alexey_sz, Вы писали:
_>Собственно немного флеймовая тема, но тем не менее. Есть два диаметральных подхода к комментариям _>1) Комментируем все, что можно _>2) Пишем код так, чтобы комментарии были не нужны . Ну или самый необходимый минимум _>Есть ли у вас требования на работе к комментариям, и если есть то какие ?
Требований особых нет, но жизнь заставляет.
Волт сейчас для одной научной лаборатории делаю несколько прог на С++.
Проги небольшие (менее 100 строк), поэтому с классами не заморачиваюсь.
Но:
1. Комментирую КАЖДУЮ переменную и константу.
2. Комментирую назначение каждой функции и ее параметров
3. Комментирую последовательность действий в больших (более 10 строк) функциях. Это требуется, ибо словарь предметной области несколько отличается от привычного...
4. Частенько добавляю комментарии о последствиях изменения того или иного участка кода.
5. Включил в проект ReadMe.txt, в котором записываю основные задачи, схемы решений и вопросы.
Хочешь быть счастливым — будь им!
Без булдырабыз!!!
AS>А если бы код был нормальный, в нем бы проверялось — находится ли файл на терминалке или на замепленном диске и если не находится, то
нормальность вовсе не очевидна. Чтобы это проверить нужно писать дополнительный непереносимый (и возможно ненадежный) код. Если дополнительное копирование не приносит каких-то нетерпимых задержек, то я был бы против добавления проверок о которых ты пишешь.
Здравствуйте, LaptevVV, Вы писали:
LVV>Здравствуйте, alexey_sz, Вы писали:
LVV>1. Комментирую КАЖДУЮ переменную и константу. LVV>2. Комментирую назначение каждой функции и ее параметров
покажите пожалуйста пример кода
LVV>3. Комментирую последовательность действий в больших (более 10 строк) функциях. Это требуется, ибо словарь предметной области несколько отличается от привычного...
обычно вместо этого функция разбивается на функции с говорящими именами
Здравствуйте, Abyx, Вы писали:
A>Здравствуйте, LaptevVV, Вы писали:
LVV>>Здравствуйте, alexey_sz, Вы писали:
LVV>>1. Комментирую КАЖДУЮ переменную и константу. LVV>>2. Комментирую назначение каждой функции и ее параметров A>покажите пожалуйста пример кода
1. Данные
#include <deque>
#include <vector>
#include <string>
#include"mersennetwister.h"using namespace std;
typedef signed char byte;
typedef unsigned int node; // -- узел --typedef unsigned short nline; // -- строка решетки -- пока достатчно short --typedef unsigned short npos; // -- позиция в строке решетки -- достатчно short --
/* -- Исходные данные:
1. L -- длина стороны решетки, 2^10 < L < 2^16
2. mera -- длина k-меры, 2 < k < L/100
3. S -- степень анизотропии, S = [-1,1]
S определяет процент вертикальных и горизонтальных к-мер.
Схема:
генерируется действительное число pS =[0,1]
приводится к диапазону [-1,+1]
если pS < S, то ориентация горизонтальная
если pS >= S, то ориентация вертикальная
можно и наоборот - это волевое решение
4. cN - количество полных jammings --
*/
// -- глобальные переменные, нужные всем --int nArg; // -- количество параметров командной строки --
// -- параметры генерации - входные данные -- из командной строки --
npos L; // -- можно signed short
npos mera; // -- можно signed shortdouble S; // -- степень анизотропиunsigned int cN; // -- количество полных jummings --
//--double pmin, pmax; // -- min и max степени заполнения решетки --
//--double step; // -- шаг степени заполнения --
// -------------------------
/* -- Нужно считать:
-- Количество занятых узлов --
-- количество вертикальных и горизонтальных занятых узлов --
-- доли заполненных узлов --
-- доля заполненных к_мер = заполненные узлы / к_мера
-- доля вертикальных мер --
-- доля горизонтальных мер --
-- степень анизотропии после заполнения --
-- для оптимизации нужно --
-- общее количество попыток = количество итераций цикла --
-- количество удачных --
-- удачные вертикальные --
-- удачные горизонтальные --
-- количество неудачных --
-- неудачные вертикальные --
-- неудачные горизонтальные --
всего попыток = удачные+неудачные
доля удачных = удачные / попытки
*/
node countU; // -- количество узлов решетки = L*L
node countD; // -- счетчик занятых узлов --
// -- горизонтальные - номер 0 = g
// -- вертикальные - номер 1 = vdouble cM[2]; // -- количество размещенных мер --double cU[2]; // -- количество размещенных узлов --double countP; // -- количество проб размещения --
// -- countP = количество итераций одного цикла заполнения решетки --double D; // -- текущая доля заполнения решетки, D = countD/double(countU);
// -- счетчики проблемных попыток и узлов --double cEmpty; // -- количество неудачных проб --double cR; // -- попытки по занятым-удаляемым узлам --double countRN; // количество редуцирований Nodes
// -- горизонтальные - номер 0 = g
// -- вертикальные - номер 1 = vdouble cE[2]; // -- неудачные пробы по can[orient] = NCheck(orient);double cnN[2]; // -- количество "плохих" свободных узловdouble p_cnN[2]; // -- количество "плохих" свободных узлов НА ПРЕДЫДУЩЕМ ШАГЕ! ---
// -- "плохой" узел - это свободный узел, от которого нельзя разместить меру --bool can[2]; // -- можно разместить меру -- по Nodes считается --double practS; // -- практическая S на каждом вычислении --
// -- она же - вычисление текущего S после каждого прогона --
vector<double> pD; // -- вектор текущих S для вычисления отклонения --extern const double kS = 1.984; // -- коэффициент для доверительного интервала --double Sigma;
// -- средние --double mD; // -- средняя доля заполненияdouble mpS; // -- средняя practS --
// -- пока не считаются --double mUg; // -- средняя доля горизонтальных узлов --double mUv; // -- средняя доля вертикальных узлов --double probably; // вероятность ориентации -- для посмотреть --enum Orientation { g, v };
Orientation orient; // -- случайная ориентация меры --
Orientation dominanta; // -- доминирующее направление по анизотропии --
// -- заполнение решетки Grid --extern const byte vd = -1; // -- вертикальный узел --extern const byte nd = 0; // -- свободный узел --extern const byte gd = +1; // -- горизонтальный узел --
// -----------------------------------typedef deque<node> Free;
Free Nodes; // -- множество свободных узлов --double porog; // -- порог сжатия списка свободных узлов --extern const double porogD = 0.6; // -- оптимальный порог заполнения решетки,
// --------------------------------------- после котрого нужно создать список свободных узлов --
// -----------------------------------
// -- битовая решетка
// -- заполнять ее при размещении меры интервала --typedef vector<byte> Line;
vector<Line> Grid; // -- решетка для демонстрации --
Line Mera; // -- мера - для поиска --
MtRng64 mtS; // анизотропия
MtRng32 mt; // -- координаты -- один общий для всех
// -- генерируемая позиция --
nline ci = -1; // -- номер строки в Grid --
npos cj = -1; // -- номер столбца в Grid --
// -- номер позиции в Nodes --
node nU = -1;
// -- для отладки -- вывод на экран --
// -- определяются в файле Debug.txt --
// -- Определен и открывается в input() - файл main.cppbool Debug = false; // -- показывать счетчики --bool showN = false; // -- показывать список Nodes после редукции --bool showGr = false; // -- показывать ли решетку --bool showDbg = false; // -- пошаговая выдача данных с решеткой --
// -- для сохранения в файле --bool saveF = true; // -- писать 4 числа в файл после N прогонов --bool DsaveR = false; // -- писать счетчики в файл JValue.txt --bool saveV = false; // -- писать все значения S после каждого размещения --bool saveGr = false; // -- писать решетку в файл --
string rFile = "JResult.txt"; // -- имя файла результатов --
FILE *Result; // -- файловая переменная для вывода результатов --
string vFile = "JValue.txt"; // -- имя файла для текущей S--
FILE *Value; // -- открывается и закрывается в main.cpp --
// -- КОНТРОЛЬНЫЕ --посчитанные по Grid -- пока не используются --double grUg; // -- узлы по горизонтали --double grUv; // -- узлы по вертикали (но считаются по строкам) --double grUn; // -- пустые узлы --
2. Код-1
// -- восстановление -- для нового цикла --void nulling()
{ printf("\nNulling");
countD = 0;
cM[g] = cM[v] = 0;
cU[g] = cU[v] = 0;
// -----------------------------
cEmpty = 0; cR = 0; countRN = 0; // -- cG = 0;
cE[g] = cE[v] = 0;
cnN[g] = cnN[v] = 0.0;
p_cnN[g] = p_cnN[v] = 0.0;
// -- восстановление решетки --
can[g] = can[v] = true;
for(nline i = 0; i < L; ++i)
{ Grid[i].assign(L, nd); // -- обнуление решетки
}
/* -- в данной версии - формируется в процессе работы --
// -- восстановление списка свободных узлов --
Nodes.resize(countU);
for(node i = 0; i < countU; ++i)
Nodes[i] = i;
*/
}
//-----------------------------------------------------------------
// -- занесение меры в решетку --
// -- заполнение на стыке --void fillJoint(nline ci, npos cj, byte ch)
{ npos Finish = (cj+mera) % L;
npos j = cj;
while(j != Finish)
{ Grid[ci][j] = ch;
j = (j + 1) % L;
}
}
// -- заполнение в доминантном направлении --inline
void dmSet(nline ci, npos cj, byte ch)
{ Line::iterator Begin = Grid[ci].begin() + cj;
npos cjR = (cj + mera) % L;
if(cj < cjR) // -- не стыковой случай --
fill_n(Begin, mera, ch);
else
fillJoint(ci, cj, ch);
}
// -- заполнение в альтернативном направлении --void nmSet(nline ci, npos cj, byte ch)
{ npos Finish = (ci+mera) % L;
npos i = ci;
while(i != Finish)
{ Grid[i][cj] = ch;
i = (i + 1) % L;
}
}
// -- занесение меры в Grid --inline
void setMera(Orientation orient, nline row, npos col)
{ byte ch;
if(orient == g) ch = gd; else ch = vd;
if(orient == dominanta) dmSet(ci,cj,ch);
else nmSet(ci,cj,ch);
}
//-----------------------------------------------------------------
// -- проверка прямо по Grid - можно ли разместить меру --
// -- проверка стыкового интервала --bool dmJoint(nline ci, npos cj)
{ bool yes = true;
npos j = cj;
npos Finish = (cj+mera) % L;
while(yes && (j != Finish))
{ if(Grid[ci][j] != nd) yes = false ;
j = (j + 1) % L;
}
return yes;
}
// -- проверка в доминантном направлении - стандартными алгоритмами --inline
bool dmCheck(nline ci, npos cj)
{ bool yes = true;
npos jR = (cj+mera) % L;
if(cj < jR)
{ Line::iterator Begin = Grid[ci].begin() + cj;
Line::iterator End = Begin + mera;
yes = equal(Begin, End, Mera.begin());
}
else yes = dmJoint(ci, cj); // проверка стыка --return yes;
}
// -- проверка в альтернативном направлении - циклом --bool nmCheck(nline ci, npos cj)
{ bool yes = true;
npos i = ci;
npos Finish = (ci+mera) % L;
while(yes && (i != Finish))
{ if(Grid[i][cj] != nd) yes = false ;
i = (i + 1) % L;
}
return yes;
}
// -- проверка размещения меры --inline
bool mCheck(Orientation orient, nline ci, npos cj)
{ bool yes = false;
if(orient == dominanta) yes = dmCheck(ci, cj);
else yes = nmCheck(ci, cj);
return yes;
}
// ----------------------------------------------
// -- удаление узла из списка --inline
void Remove(node nU)
{ swap(Nodes[nU], Nodes.back()); // -- это нарушает сортировку --
Nodes.pop_back();
}
//-----------------------------------------------
// -- проверка возможности разместить меру по свободным узлам --
// -- для доминантного направления работает на каждом цикле --bool NCheck(Orientation orient)
{ bool yes = false;
nline ci;
npos cj;
cnN[orient] = 0.0; // -- количество "плохих" узлов --
Free::iterator iN = Nodes.begin();
while(!yes && (iN != Nodes.end()))
{ ci = (*iN) / L;
cj = (*iN) % L;
yes = mCheck(orient, ci, cj);
if(!yes) ++cnN[orient];
++iN;
}
return yes;
}
3. Большая функция --
// -- однократное заполнение решетки --
// -- окончание - полное заполнение решетки основного направления --
// -- метод 2: для данной анизотропии генерим координаты до упора --void Method2()
{ clock_t t0 = tTime("Before nulling ");
nulling();
clock_t t1 = tTime("After nulling ");
printf("\nTime nulling = %12.3lf", double(t1 - t0)/CLOCKS_PER_SEC);
// -- начинаем --
countP = 0; // оно же - счетчик итераций цикла --
printf("\n-----------------------------------");
bool yes = false; // разместили ли меру --
clock_t start, end, start1, end1;
start = tTime("Before Loop ");
/* -- окончание работы: невозможно разместить меру доминантного направления --
-- Первый цикл: безусловное заполнение решетки до порога
координаты генерятся и проверяются непосредственно на решетке --
-- Создание списка "хороших" свободных узлов
-- Второй цикл: генерация координат из списка свободных узлов --
*/
// -- первый цикл- заполнение до порога --
D = countD/double(countU); // -- доля заполнения решетки --bool Condition = (D < porogD); // -- условие - по доле заполнения --
start1 = tTime("Before Loop---1 ");
while(Condition) // -- текущая доля не превышает порога --
{ ++countP; // -- количество попыток размещения мер --
// -------------------------------------------------
// -- генерируем ориентацию --
probably = mtS.getReal1();
// -- pS = round() * 2 - 1
// -- [-1,S) - горизонталь --
// -- [S,+1] - вертикаль --
// -- Чем больше S, тем больше горизонтальных и меньше вертикальных --double pS = probably * 2.0 - 1.0;
if (pS < S) orient = g; else orient = v;
// -- для заданной ориентации генерим координаты, пока не разместим меру --
yes = false; // -- размещается ли мера
ci = cj = -1;
// --------------------------------------------------
// -- генерация узлов --
// -- если доминанта - горизонталь, то ci - номер строки Grid --
// -- если доминанта - вертикаль, то ci - номер столбца Grid --
nU = mt.getUint() % countU; // -- генерим номер узла --
ci = nU / L; // -- номер строки --
cj = nU % L; // -- номер столбца --
yes = mCheck(orient, ci, cj); // -- проверяем данный узел --
// -- генерим до упора --while(!yes) // -- до упора генерим --
{ ++cEmpty; // -- неудачная попытка --
nU = mt.getUint() % countU;
ci = nU / L;
cj = nU % L;
yes = mCheck(orient, ci, cj);
}
// -- все-таки попали на нужный узел - размещаем меру --
setMera(orient, ci, cj); // -- заполняем решетку --
countD += mera; ++cM[orient]; // -- прибавить узлов и мер --
cU[orient] += mera; // -- прибавить ориетированных узлов --if(saveV) // -- если нужны все промежуточные S --
{ practS = (cM[g]-cM[v])/(cM[g]+cM[v]);
fprintf(Value,"%12.9lf\n", practS);
}
D = countD/double(countU); // -- доля заполнения --
Condition = (D < porogD); // can[dominanta] = NCheck(dominanta); // -- условия окончания --
// ----- отладочное ------------------------------------if(showDbg) printDbg();
} // -- конец цикла ------------------------------
end1 = tTime("After Loop---1 ");
printf("\nTime = %12.3lf", double(end1 - start1)/CLOCKS_PER_SEC);
// -- создание списка свободных узлов --
clock_t start_mN = tTime("Before make Nds ");
makeNodes();
clock_t finish_mN = tTime("After make Nds ");
printf("\nTime = %12.3lf", double(finish_mN - start_mN)/CLOCKS_PER_SEC);
// -- второй цикл --
start1 = tTime("Before Loop---2 ");
clock_t fin1, fin2;
Condition = true; // -- для первого входа по списку свободных узлов --while(Condition) // -- текущая доля не превышает порога --
{ ++countP; // -- количество попыток размещения мер --
// -------------------------------------------------
// -- генерируем ориентацию --
probably = mtS.getReal1();
// -- pS = round() * 2 - 1
// -- [-1,S) - горизонталь --
// -- [S,+1] - вертикаль --
// -- Чем больше S, тем больше горизонтальных и меньше вертикальных --double pS = probably * 2.0 - 1.0;
if (pS < S) orient = g; else orient = v;
// -- для заданной ориентации генерим координаты, пока не разместим меру --
yes = false; // -- размещается ли мера
ci = cj = -1;
// --------------------------------------------------
// -- оптимизация списка свободных узлов --
// -- условие запуска gNodes() - эвристическое --if((cnN[g] != p_cnN[g])&&(cnN[v] != p_cnN[v]))
if((cnN[g]+cnN[v] > porog)&& // -- порог - тут возможны варианты --
(Nodes.size() > porog) // -- чтобы мелкие не оптимизировать --
)
gNodes(); // -- удаляем "плохие" узлы --
// --------------------------------------------------
// -- генерация узлов --
// -- если доминанта - горизонталь, то ci - номер строки Grid --
// -- если доминанта - вертикаль, то ci - номер столбца Grid --
nU = mt.getUint() % Nodes.size();
ci = Nodes[nU] / L;
cj = Nodes[nU] % L;
// -- исправлено 26.03.11 -------
// -- проверку надо ДО, а не после --if(orient != dominanta) // для доминанты считаем в конце цикла --
can[orient] = NCheck(orient); // -- можно ли в принципе разместить по данной ориентации --if(can[orient]) // если размещение возможно --
{ yes = mCheck(orient, ci, cj); // -- проверяем данный узел --while(!yes) // -- до упора генерим --
{ ++cEmpty; // -- неудачная попытка --if(Grid[ci][cj] != nd) // -- узел "плохой"
{ Remove(nU); ++cR; } // -- удаляем его из списка свободных узлов --
nU = mt.getUint() % Nodes.size();
ci = Nodes[nU] / L;
cj = Nodes[nU] % L;
yes = mCheck(orient, ci, cj);
// -- здесь получалось иногда так:
// ---- ориентация - недоминантная --
// -- узлы свободные по доминантной ориентации есть, а по недоминантной - нет
// ---- происходит зацикливание -- !!! --
/* -----
fin1 = tTime("Inside while ", false);
if(double(fin1 - start1)/CLOCKS_PER_SEC > 1.0)
{ printf("\nInside while - stop! ");
printCoord();
printGrid();
printNodes();
system("pause");
}
----- */
}
// -- все-таки попали на нужный узел - размещаем меру --
setMera(orient, ci, cj); // -- заполняем решетку --
countD += mera; ++cM[orient]; // -- прибавить узлов и мер --
cU[orient] += mera; // -- прибавить ориетированных узлов --
Remove(nU); ++cR; // -- удаляем размещенный узел --
// -- выводим текущее S --if(saveV)
{ practS = (cM[g]-cM[v])/(cM[g]+cM[v]);
fprintf(Value,"%12.9lf\n", practS);
}
} // -- меру по данному направлению разместить нельзяelse// -- нет хороших узлов --
{ ++cE[orient]; ++cEmpty; }
// -- исправлено 26.03.11 -------
//if(orient != dominanta) // для доминанты считаем в конце цикла --
// can[orient] = NCheck(orient); // -- можно ли в принципе разместить по данной ориентации --
Condition = can[dominanta] = NCheck(dominanta); // -- условия окончания --
// ----- отладочное ------------------------------------if(showDbg) printDbg();
} // -- конец цикла ------------------------------
end1 = tTime("After Loop---2 ");
printf("\nTime = %12.3lf", double(end1 - start1)/CLOCKS_PER_SEC);
end = tTime("After Loop ");
printf("\nTime = %12.3lf", double(end - start)/CLOCKS_PER_SEC);
D = countD/double(countU); // -- доля заполнения --
practS = (cM[g]-cM[v])/(cM[g]+cM[v]); // -- последний штрих --
printResult(Debug); // -- вывод результатов на экран --
saveResult(DsaveR); // -- пишем в файл JResult.txt --
//if(Debug) system("pause");
} // -- конец функции --
LVV>>3. Комментирую последовательность действий в больших (более 10 строк) функциях. Это требуется, ибо словарь предметной области несколько отличается от привычного... A>обычно вместо этого функция разбивается на функции с говорящими именами
Имена говорящие. Но теория перколяции — вам что-нить говорит?
Хочешь быть счастливым — будь им!
Без булдырабыз!!!
вы уж извините за прямоту, но это говнокод. от первой до последней строчки
LVV>typedef unsigned int node; // -- узел -- LVV>typedef unsigned short nline; // -- строка решетки -- пока достатчно short -- LVV>typedef unsigned short npos; // -- позиция в строке решетки -- достатчно short --
что мешает назвать node, node_line, node_line_position ?
LVV>int nArg; // -- количество параметров командной строки --
commandLineArgN или commandLineArgQty, или commandLineArgCount
LVV>npos L; // -- можно signed short
а тут почему не написали что такое L ?
.... и еще куча примеров как не надо писать код
LVV>// -- исправлено 26.03.11 ------- LVV> //if(orient != dominanta) // для доминанты считаем в конце цикла -- LVV> // can[orient] = NCheck(orient); // -- можно ли в принципе разместить по данной ориентации -- LVV> Condition = can[dominanta] = NCheck(dominanta); // -- условия окончания --
для этого есть система контроля версий
Здравствуйте, alexey_sz, Вы писали:
_>Собственно немного флеймовая тема, но тем не менее. Есть два диаметральных подхода к комментариям _>1) Комментируем все, что можно _>2) Пишем код так, чтобы комментарии были не нужны . Ну или самый необходимый минимум _>Есть ли у вас требования на работе к комментариям, и если есть то какие ?
Ну, традиционный подход заключается в том, что комментарии описывают, ЧТО программа делает, а код — КАК она это делает. Плюс, неочевидные места тоже надо описывать.
Если комментировать все, что можно, за комментариями сути не видно. А писать код так, чтобы комментарии были не нужны, невозможно. Вернее, возможно, но при одном условии: код тоже никому не нужен
Здравствуйте, Abyx, Вы писали: A>вы уж извините за прямоту, но это говнокод. от первой до последней строчки
Ради Бога...
А судьи — кто? LVV>>typedef unsigned int node; // -- узел -- LVV>>typedef unsigned short nline; // -- строка решетки -- пока достатчно short -- LVV>>typedef unsigned short npos; // -- позиция в строке решетки -- достатчно short -- A>что мешает назвать node, node_line, node_line_position ?
Писать длинно... LVV>>int nArg; // -- количество параметров командной строки -- A>commandLineArgN или commandLineArgQty, или commandLineArgCount
Опять же — длинно. Тем более, что используется один раз. LVV>>npos L; // -- можно signed short A>а тут почему не написали что такое L ?
Это я и так помню... А вам — не нужно... A>.... и еще куча примеров как не надо писать код
Не пишите... LVV>>// -- исправлено 26.03.11 ------- LVV>> //if(orient != dominanta) // для доминанты считаем в конце цикла -- LVV>> // can[orient] = NCheck(orient); // -- можно ли в принципе разместить по данной ориентации -- LVV>> Condition = can[dominanta] = NCheck(dominanta); // -- условия окончания -- A>для этого есть система контроля версий
Овчинка выделки не стОит.
Вы спрашивали о комментариях — получили развернутый ответ.
А код я обсуждать не собираюсь.
Хочешь быть счастливым — будь им!
Без булдырабыз!!!
Здравствуйте, alexey_sz, Вы писали:
_>2) Пишем код так, чтобы комментарии были не нужны . Ну или самый необходимый минимум
только так и никак иначе
ниже приведен код с комментариями.
я считаю что он читается достаточно нормально и без комментариев, однако на всякий случай там есть комментарий для объяснения потенциально сложной идиомы
(код плохой изза опасной копипасты, но мы счя не об этом)
Здравствуйте, LaptevVV, Вы писали:
LVV>Писать длинно...
да, длинно. А иногда ОЧЕНЬ длинно. Зато читабельно.
Зато можно в меню рефакторинга ткнуть "переименовать", и мгновенно переименовать. с комментриями так не получится.
Идентификатор он атомарен, его можно копировать, менять, при этом средство рефакторинга может найти все идентификаторы, а компилятор проверить.
А вот комментарии не имеют надежной привязки к тому что они комментируют.
Вот у вас написано LVV>npos L; // -- можно signed short
наверное там было в начале написано
signed short L; // -- можно signed short
а потом стало
npos L; // -- можно signed short
и комментарий стал бесполезным
завтра npos станет signed int, а комментарий останется. и это будет уже не бесполезный, а вредный комментарий.
Но это ваш код. Вы можете писать там что хотите, я только надеюсь что мне никогда не придется поддерживать этот ваш код.
Здравствуйте, Abyx, Вы писали:
LVV>>Писать длинно... A>да, длинно. А иногда ОЧЕНЬ длинно. Зато читабельно. A>Зато можно в меню рефакторинга ткнуть "переименовать", и мгновенно переименовать. с комментриями так не получится. A>Идентификатор он атомарен, его можно копировать, менять, при этом средство рефакторинга может найти все идентификаторы, а компилятор проверить.
Не, не люблю писать длинно... A>А вот комментарии не имеют надежной привязки к тому что они комментируют. A>Вот у вас написано LVV>>npos L; // -- можно signed short A>наверное там было в начале написано A>signed short L; // -- можно signed short A>а потом стало A>npos L; // -- можно signed short A>и комментарий стал бесполезным A>завтра npos станет signed int, а комментарий останется. и это будет уже не бесполезный, а вредный комментарий.
Ваши предположения — беспочвенны. С самого начала было npos. Комментарий — себе, просто напоминание. A>Но это ваш код. Вы можете писать там что хотите, я только надеюсь что мне никогда не придется поддерживать этот ваш код.
Его и не требуется сопровождать. Работа конкретная и разовая. Заказчика — устраивает достигнутый результат.
Меня в ДАННОМ СЛУЧАЕ устраивает мой стиль, в котором разбираться только мне.
Хочешь быть счастливым — будь им!
Без булдырабыз!!!
Здравствуйте, LaptevVV, Вы писали:
LVV> Вот сейчас для одной научной лаборатории делаю несколько прог на С++. LVV> Проги небольшие (менее 100 строк), поэтому с классами не заморачиваюсь.
Тогда это тогда не С++, а С и классы не заморочка
LVV> Но: LVV> 1. Комментирую КАЖДУЮ переменную и константу. LVV> 2. Комментирую назначение каждой функции и ее параметров LVV> 3. Комментирую последовательность действий в больших (более 10 строк) функциях. Это требуется, ибо словарь предметной области несколько отличается от привычного... LVV> 4. Частенько добавляю комментарии о последствиях изменения того или иного участка кода.
Глянул код с комментами, как для меня так их слишком много.
LVV> 5. Включил в проект ReadMe.txt, в котором записываю основные задачи, схемы решений и вопросы.
Лучше бы там записать псевдокод программы с "большими" комментами, а в коде оставить не больше одной линии на коммент внутри функции.
Здравствуйте, AlexNek, Вы писали:
AN>Здравствуйте, LaptevVV, Вы писали:
LVV>> Вот сейчас для одной научной лаборатории делаю несколько прог на С++. LVV>> Проги небольшие (менее 100 строк), поэтому с классами не заморачиваюсь. AN>Тогда это тогда не С++, а С и классы не заморочка
Только я STL использую.
Векторы, деки, списки и стандартные алгоритмы. LVV>> Но: LVV>> 1. Комментирую КАЖДУЮ переменную и константу. LVV>> 2. Комментирую назначение каждой функции и ее параметров LVV>> 3. Комментирую последовательность действий в больших (более 10 строк) функциях. Это требуется, ибо словарь предметной области несколько отличается от привычного... LVV>> 4. Частенько добавляю комментарии о последствиях изменения того или иного участка кода. AN>Глянул код с комментами, как для меня так их слишком много.
Предметная область мне незнакомая. Алгориттмы — специфические. Поэтому комментю, чтобы не забывать... LVV>> 5. Включил в проект ReadMe.txt, в котором записываю основные задачи, схемы решений и вопросы. AN>Лучше бы там записать псевдокод программы с "большими" комментами, а в коде оставить не больше одной линии на коммент внутри функции.
Частично я так и делаю. Для отдельный частей задачи.
Хочешь быть счастливым — будь им!
Без булдырабыз!!!
