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

угу. вот только не следует думать, что если ваш класс отлично работает с типом int, то вы можете отдать его другим программистам, и он будет хоть как-то работать с их типами. Сила С++ в том и заключается, что можно один раз написать класс который сортирует, а потом им сортировать что угодно. Если "не забивать голову", то ваш класс никому будет не нужен. В том числе и вам. Ибо отсортировать ваши инты проще без создания отдельного класса только для этого.

в с++ код утилизируется при помощи классов, если длинна кода в обоих случаях (с и с++) одинакова, как заявил док, то как он утилизируется в с?

обычно длинна кода в С++ несколько больше. КАЖУЩАЯСЯ простота кода С++ объясняется просто: мы например можем использовать чужие классы, причём делать это очень элегантно. К примеру, у нас есть массив в С, мы хотим его отсортировать. Если в С для этого применить qsort (из стандартной либы), получится:

       #include <stdio.h>
       #include <stdlib.h>
       #include <string.h>

       static int
       cmpstringp(const void *p1, const void *p2)
       {
           /* The actual arguments to this function are "pointers to
              pointers to char", but strcmp(3) arguments are "pointers
              to char", hence the following cast plus dereference */

           return strcmp(* (char * const *) p1, * (char * const *) p2);
       }

       int
       main(int argc, char *argv[])
       {
           int j;

           if (argc < 2) {
            fprintf(stderr, "Usage: %s <string>...\n", argv[0]);
            exit(EXIT_FAILURE);
           }

           qsort(&argv[1], argc - 1, sizeof(char *), cmpstringp);

           for (j = 1; j < argc; j++)
               puts(argv[j]);
           exit(EXIT_SUCCESS);
       }

Совсем другой коленкор, если мы имеем абстрактный базовый класс collection. Нам надо сделать следующее:
1) унаследовать свой класс element от класса collection_element
2) перезагрузить функцию collection_element::compare() своей element::compare()
3) и всё. теперь мы смело можем писать my_collection.qsort();

Вот только, qsort от этого не стала не проще, и не быстрее. (медленнее тоже не стала, ибо оптимизирующий компилятор выкинет весь лишний синтаксический мусор. И указатель на функцию так и останется, правда спрятанный в VTable экземпляра класса.).

процессор всё равно не структурный, а функциональный. В процессоре нету никаких классов. Потому, из C++ получается что-то вроде C, а уж него - ассемблер.

В моём примере, на самом деле, компилятор превращает гламурное my_collection.qsort(); в готичное
qsort(&argv[1], argc - 1, sizeof(char *), cmpstringp);
при этом, сам подставляет все эти ужасные типы, и сам заботится о деталях (в частности, куда указывает cmpstringp в данный момент времени. Это плюшка на самом деле приколочена к любому классу с виртуальными функциями. Только кодер её не видит. Но она есть. Дизассемблер вам поможет её увидеть.).

Basic вроде бы...
Delphi очень похоже.

странно... ни то ни другое почти не знаю))

всё так только в теории... на практике для простых типов машинный код получается одинаковый с точностью до порядка некоторых команд и некоторых странных действий... на самом деле в стандарте я нашёл только косвенные намёки на то, что для простых типов вызываются "операторы"... так что голову этим можно себе не забивать. (ещё раз подчеркну, что речь идёт только о простых типах)

Ни фига подобного

моя ошибка... перепутал с чем-то... в каком-то ЯП можно даже наследовать от базовых типов(в каком не помню...)

drBatty пишет:

да не разу он не совместим. встроенный тип int на самом деле - встроенный тип. Это имитация целого числа. На самом деле, это класс, со своими методами и со своими конструкторами.

вас опять понесло? это в java так вроде

Ни фига подобного  wink

x = y + z; /* складываем y с z, и результат пишем в x */

А в С++

x = y + z;// эквивалентно
x.operator=(y.operator+(z));// причём все эти операторы могут быть разные, для разных x, y и z.
// ИЧСХ по умолчанию задан лишь operator=, и то, всего один
// ИЧСОХ для встроенных типов есть встроенные операторы, которые работают почти как в Си

т.е. при записи "int a;" идёт речь о создании объекта a типа int... но ИРЛ отичий от си нет...

тут основное отличие в том, что вообще говоря, в С++ пишется

int x(17);// конструктор копий int::int(int)

а в Си

int x = 17;/* обявление переменной x и запись туда 17и */

в ++ тоже можно как в Си, но это костыль для совместимости.
конструктор копий и оператор = в плюсах (для совместимости) заданы по умолчанию, и осуществляют копирование байт-в-байт. Эти грабли могут очень больно долбануть кодера по его глупой башке. Посему, обычно конструктор копий и оператор= закрываются:

class foo
{
 private:
  const foo &operator=(const foo &) {}
  foo(const foo &) {}
 public:
};

пользователь класса лишается возможности случайно сделать копию.

Тут про наследование говорили - те ещё вилы 
Дело в том, что деструктор не наследуется в базовом классе от производного. Потому, если в производном классе выделено 100500 памяти, и уничтожается объект как базовый (обычная практика) - привет утечки памяти 
Лекарство - надо делать виртуальные деструкторы. (виртуальные нормально наследуются).

но ИРЛ отичий от си нет...

в том-то и дело, что IRL  с int никто дела не имеет...

ну под рукой нет конечно. но на самом деле - так и есть. конечно, компилятор может и не так считать. ЧСХ - стандарт это позволяет. С++ специально так построен - там костыль на костыле: например

глупый вопрос, а где стандарт скачать?

1) а что говорит ваш g++?
2) x это у вас константа? Тогда и x-- - --x; тоже константа, и вычисление происходит на этапе компиляции (а не в рантайме). Причём на этапе компиляции константные целые выражения вычисляются в точности как в С, с самой высокой степенью оптимизации. А в этих условиях получается именно 0.

он это и говорит... пробовал и так, и эдак...

не пишу -Wall по всем мелочам))

си не такой запутанный, но написать на нём быдлокод ещё проще smile

ЗЫ: ещё один UB:

x = y =  x-- - --x;

у меня x = -1; y=0; в общем причины понятны, но смотрится забавно smile

вас опять понесло? это в java так вроде

про джаву - не в курсе.

ну под рукой нет конечно. но на самом деле - так и есть. конечно, компилятор может и не так считать. ЧСХ - стандарт это позволяет. С++ специально так построен - там костыль на костыле: например
int x = 17;
это на самом деле
int x(17);
т.е. вызов конструктора по умолчанию. Естественно, на деле вызывается конструктор копирования по умолчанию, и в коде это выглядит точно так-же.

по логике он может вернуть 0 1 и 2, а на практике он может вернуть 100500 и это будет верно.

не. для классического компьютера только 0, 1, или 2. Для неклассического действительно 100500 может. А может и диск форматнуть.  smile

1) а что говорит ваш g++?
2) x это у вас константа? Тогда и x-- - --x; тоже константа, и вычисление происходит на этапе компиляции (а не в рантайме). Причём на этапе компиляции константные целые выражения вычисляются в точности как в С, с самой высокой степенью оптимизации. А в этих условиях получается именно 0.

а вам об этом компилятор ваш разве не сказал?  oO
мой меня за такое быдлокодером в открытую обзывает  wink
Конечно UB. Но вот только не в С++.
Точнее говоря, я точно не знаю, является-ли этот быдлокод UB с т.з. стандарта C++, или нет. С++ вообще довольно запутанный язык, и написать быдлокод на нём куда как проще. (и часто компилятор молчит в тряпочку).