- cNoNim
- Постоялец
MihaiL
кстати на счет "запятой", какойто левый оператор получается...
так и не придумал вменяемого места где его можно пристроить, так как он работает как то странно, и его поведение меняется в зависимости от скобок
Sbtrn. Devil
> int (vector4d::*x1)
Интересная штука :)
Хотя я бы сделал так:
class vector2d { public: // ... int x,y; }; class vector4d { public: // ... int x,y,z,w; vector2d& Swizle(int idx1, int idx2, vector2d& Vec2d = vector2d( )) { Vec2d.x = ( &x)[idx1]; Vec2d.y = ( &x)[idx2]; return Vec2d; }; }; vector4d v4; vector2d v2_xy = v4.Swizle( 0,1); vector2d v2_zx = v4.Swizle( 2,0); vector2d v2_ww = v4.Swizle( 3,3);
И никаких копипаст :)
Хм... После бейсиков и паскалоидов вообще сам C в целом был большим открытием. Особенно поражало то насколько это всё логично, просто и эффективно, из-за того что примерно в то же время изучал асм и проникался тем что в нём всё это красиво выражается.
Так, навскидку:
- условия в условных операторах тупо сравниваются на ноль. CMP/JMPZ в действии. понятно что в асме нет разницы между тем указатель у тебя в регистре, int или char - значит и if получается "универсальным" для всех примитивных типов. т.е. вместо усложнений вида "выражение в if должно иметь тип boolean" получаем наоборот упрощение и при этом расширение возможностей! кууууль!
- отсутствие принципиальной разницы между процедурами и функциями. при этом любое выражение есть вычисление функции и отбрасывание результата! два правила поистине сочетаются в гармонию. в допотопных сях, где еще не было типа void красиво (вернее очень просто и без исключельных проверок в компиляторе) на асме реализовывалась в то, что в аккумуляторе возвращалось мусорное значение, т.е. func() имело тип возврата int, что опять таки подчинялось другому уже отвергнутому современными компилами правилу.
- универсальная форма for. no comments.
Из более современных "открытий" - конечно же специализированные шаблоны и трюки с ними Александреску. Но сам этим не пользуюсь.
cNoNim
> кстати на счет "запятой", какойто левый оператор получается...
Солидарен. Исторически он появился чтобы обеспечить универсальную форму for. Я где-то предлагал альтернативу синтаксису чтобы и for сохранить и оператор , логически превращался в ;
P.S.
Т.е. как оператор(,) работал бы ;. По той же логике. Вычислять и отбрасывать всё с самого начала, а результат последнего выражения возвращать. Позволило бы достигнуть еще большей гармонии будучи дополненным логичным "функция возвращает результат внутри { }:
Т.е.
int func( int x )
{
x * x;
};Возвращает квадрат икса.
int func( int x )
{
int y = x * x;
y * x;
};возращает куб икса. return становится лишь вспомогательным средством досрочного выхода с результатом.
А for имел бы чуток другой, но более логичный, синтаксис: for(x=0;y=0,y++;x++,y<10). Заметьте, что запятая сохранила здесь свою концепцию РАЗДЕЛИТЕЛЯ ПАРАМЕТРОВ в скобках. Что упрощает еще и работу синтаксическому разборщику компилятора и все концепты языка оказываются на еще большем и красивом месте, нежели в текущем стандарте.
1. Что в начале всех нестатичных методов класса идет скрытый указатель на this
2. Виртуальный деструктор
3. m[n] == n[m] (уже писали выше)
В таком вот примерно порядке я это узнавал, да вот давно ничему не удивлялся уже в С++
KpeHDeJIb
> 1. Что в начале всех нестатичных методов класса идет скрытый указатель на this
Могу только догадываться что такое "в начале", но в любом случае сие - implementation dependent, поэтому любое утверждение тут неверно.
Ghost2
> но в любом случае сие - implementation dependent, поэтому любое утверждение тут
> неверно.
не думаю что это implementation dependent
Мне больше всего понравились виртуальные операторы для классов. В частности operator().
destrator
> vector2d& Swizle(int idx1, int idx2, vector2d& Vec2d = vector2d())
> {
> Vec2d.x = (&x)[idx1];
> Vec2d.y = (&x)[idx2];
> return Vec2d;
> };
Руки бы тебе отрубить за говнокод ;)
Правка: не, не удержался. Ну вот что по твоему этот метод возвращает ? Про конструкцию "(&x)[idx1]" пока не буду говорить даже.
> Мне больше всего понравились виртуальные операторы для классов. В частности operator().
Функторами увлекаешься?
Necrys
Ну когда-то увлекался, и виртуальный ор() был очень в тему =)
destrator
> Хотя я бы сделал так:
Union в таких случаях предпочтительней, наверно.
KpeHDeJIb
> m[n] == n[m]
хм, интересно)
Sbtrn. Devil
> Это крутейшая вещь.
> struct A
> {
> int x;
> int y;
> };
>
> void ProcessA (A &a,int (A::*z))
> {
> (a.*z)++;
> }
>
> ...
> A a;
> ProcessA (a, &A::x); // x++
> ProcessA (a, &A::y); // y++
Чем тебя не устраивает
void ProcessA (int* pVal) { ++( *pVal); } A a; ProcessA ( &a.x); // x++
??
кстати внесу свои пять копеек :)...
последнее что меня порадовало в С++,
это template конструкторы... в принципе то в них все логично, но я раньше их как то неюзал :)...
также очень радуют нововведения нового стандарта
вроде auto и lambda
cNoNim
> также очень радуют нововведения нового стандарта
> вроде auto и lambda
лямда меня тоже радует, но судя по всему новый стандарт можно будет юзать не раньше чем через пару-тройку лет после выхода официального. Тк для совместимости со старыми компилерами наверняка все будут писать по старому.
Ghost2
> но в любом случае сие - implementation dependent
Пользовался только msvc, bc и gcc. Там везде одинаково, а где по другому, простите? Или это "может быть по другому"?
Тема в архиве.