Популярные вопросы на собеседовании по C++ и ответы на них

    Здравствуйте!

    Те, кто занимается программированием рано или поздно сталкивается с необходимостью прохождения технического собеседования у потенциального работодателя.

    О том, что спрашивают на собеседовании у C++ программистов, а также об ответах на эти вопросы и пойдет речь в данном посте.

    Предисловие


    Небольшая вводная часть в виде вопрос-ответ, чтобы разъяснить некоторые моменты и постараться ответить на возможные вопросы по этому посту.

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

    В общем хочется иметь список с самыми популярными вопросами по данной теме, и если, вдруг, понадобится освежить знания, чтобы не приходилось лезть в какие-то записки, запускать IDE или гуглить, а можно было открыть одно место и там все прочитать.

    Наиболее интересной данная тема должна показаться тем, кто еще только начинает свои шаги в этом безграничном море под названием C++.

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

    Какая будет структура этих вопросов?
    Линейный список. Вопросы будут добавляться по мере поступления, я постараюсь не забрасывать данный раздел и обновлять его. В конце я буду ставить дату последнего обновления, чтобы было понятно когда список меняли последний раз.

    Сейчас я планирую написать первые 20 вопросов, а если эта тема будет востребована, то буду постепенно добавлять новые.

    У вас ошибка в коде, как вы ее проглядели?
    Людям свойственно ошибаться и я не считаю себя гуру способному писать безошибочно. И это C++, здесь вероятность ошибиться еще больше.

    Если вы видите ошибку, напишите о ней, и я обязательно ее исправлю.

    Q & A


    1. Зачем нужен виртуальный деструктор?

    Ответ: Чтобы избежать возможной утечки ресурсов или другого неконтролируемого поведения объекта, в логику работы которого включен вызов деструктора.
    Пример:
    class Base
    {
    public:
        virtual ~Base()
        {
            std::cout << "Hello from ~Base()" << std::endl;
        }
    };
    
    class Derived : public Base
    {
    public:
        virtual ~Derived()
        {
            // Здесь могла бы быть очистка ресурсов
            std::cout << "Hello from ~Derived()" << std::endl;
        }
    };
    
    Base *obj = new Derived();
    delete obj;
    

    Output:
    Hello from ~Derived()
    Hello from ~Base()


    Без ключевого слова virtual у родительского класса Base деструктор порожденного класса не был бы вызван. Т.е. вызвался бы только ~Base():

    Output:
    Hello from ~Base()

    Более подробно об этом написал GooRoo здесь. Наглядный пример возможной утечки в следующем вопросе.

    2. Что стоит помнить при использовании исключений в конструкторе объекта?

    Ответ: Если исключение не обработано, то c логической точки зрения разрушается объект, который еще не создан, а с технической, так как он еще не создан, то и деструктор этого объекта не будет вызван.
    Пример:
    class Base
    {
    private: 
        HANDLE m_hFile;
    
    public:
        Base()
        {
            std::cout << "Hello from Base()" << std::endl;
            m_hFile = ::CreateFileA(...);
            // Вызываем код, который в ходе своего выполнения бросает исключение
            SomeLib.SomeFunc(...);
        }
    
        virtual ~Base()
        {
            std::cout << "Hello from ~Base()" << std::endl;
            // Здесь мы планировали закрыть хэндл
            ::CloseHandle(m_hFile);
        }
    };
    
    try
    {
        Base b;
    }
    catch(const std::exception &e)
    {
        std::cout << "Exception message: " << e.what() << std::endl;
    }
    

    Output:
    Hello from Base()
    Exception message: Something failed


    Я немного модифицировал предыдущий пример, чтобы проблема была наглядней. Здесь объект m_hFile (если был открыт) утечет т.к. до CloseHandle() выполнение не дойдет. Т.е. имеем такие же проблемы как в первом примере: возможная утечка ресурсов или другие проблемы из-за нарушения логики работы класса.

    Здесь могут спросить: «Как бы вы поступили при подобной ситуации». Правильный ответ: «Воспользовался бы умными указателями». Простой пример умного указателя:
    class Base
    {
    private: 
        class CHandle
        {
        public:
            ~CHandle()
            {
                ::CloseHandle(m_handle);
            }
        private:
            HANDLE m_handle;
        public:
            // Для полноценного smart pointer'а перегрузки одной операции
            // не достаточно, но для нашего примера и понимания вполне хватит
            void operator = (const HANDLE &handle)
            {
                m_handle = handle;
            }
        };
    
        CHandle m_hFile;
    
    public:
        Base()
        {
            std::cout << "Hello from Base()" << std::endl;
            m_hFile = ::CreateFileA(...);
            // Вызываем код, который в ходе своего выполнения бросает исключение
            SomeLib.SomeFunc(...);
        }
    
        virtual ~Base()
        {
            std::cout << "Hello from ~Base()" << std::endl;
        }
    ...
    

    Теперь и без вызова деструктора Base хэндл будет закрыт, т.к. при уничтожении класса Base будет уничтожен объект m_hFile класса CHandle, в деструкторе которого и будет закрыт хэндл.

    Изобретать велосипед, конечно, не надо, все уже написано до нас, это пример который можно написать на бумажке при соответствующем вопросе. А так есть boost, Loki, ATL и т.п., где это уже реализовано.

    3. Для каких целей применяется ключевое слово const?

    Ответ:
    1. Позволяет задать константность объекта
    2. Позволяет задать константность указателя
    3. Позволяет указать, что данный метод не модифицирует члены класса, т.е. сохраняет состояние объекта
    Пример 1. Не можем изменить значение объекта:
    const int i = 1;
    i = 2; // error C3892: 'i' : you cannot assign to a variable that is const
    

    Пример 2. Не можем изменить указатель на объект:
    int i = 1;
    int* const j(&i);
    int k = 2;
    *j = k; // Ok
    j = &k; // error C3892: 'j' : you cannot assign to a variable that is const
    


    Пример 3. Не можем изменить члены класса:
    class Foo
    {
    private:
        int i;
    public:
        void func() const
        {
            i = 1; // error C3490: 'i' cannot be modified because it is being accessed through a const object
        }
    };
    

    Дополнение: константный метод может изменять члены класса, если они объявлены как mutable. Подробнее про mutable можно прочитать у Алены CPP здесь.

    4. Можете ли вы написать пример какого-нибудь алгоритма сортировки?

    Ответ: Пузырьковая сортировка, для контейнеров, без временных переменных:
    template <typename T >
    void bubble_sort( T &a )
    {
        for( T::size_type i = 0; a.size() && i < a.size() - 1; ++i )
        {
            for( T::size_type j = i; j + 1 > 0; --j )
            {
                if( a[j] > a[j+1] )
                    std::swap( a[j], a[j+1] );
            }
        }
    }
    
    std::vector<int> v;
    v.push_back( 7 );
    v.push_back( 1000 );
    v.push_back( 134 );
    v.push_back( 23 );
    v.push_back( 1 );
    bubble_sort( v );
    

    5. Можете ли вы написать код для переворота строки?

    Ответ: Код переворота строки для контейнеров, без временных переменных, не осуществляющий прохода по всей строке:
    template <typename T >
    void invert_string( T &a )
    {
        T::size_type length = a.size();
        for( T::size_type i = 0; i < (length/2); ++i )
        {
            std::swap( a[i], a[length - i - 1] );
        }
    }
    
    std::string str = "abcdefg";
    invert_string(str);
    

    6. Как защитить объект от копирования?

    Ответ: Сделать private конструктор копирования и оператор =.
    Пример:
    class NonCopyable
    {
    public:
        NonCopyable(){}
    
    private:
        NonCopyable(NonCopyable&){}
        
    private:
        void operator=(const NonCopyable&){}
    };
    
    NonCopyable a; 
    NonCopyable b = a; // error C2248: 'NonCopyable::NonCopyable' : cannot access private member
    a = b; // error C2248: 'NonCopyable::operator =' : cannot access private member
    

    7. В чем разница между struct и class?

    Ответ: Практически ни в чем. В struct модификаторы доступа по умолчанию public, в class private. Также отличается и наследование по умолчанию, у structpublic, у classprivate.
    Пример:
    struct Foo
    {
        int i;
    };
    class Bar
    {
        int i;
    };
    
    Foo a;
    a.i = 1; // Ok
    Bar b;
    b.i = 1; // error C2248: 'Bar::i' : cannot access private member declared in class 'Bar'
    

    8. Каким свойством должен обладать объект, чтобы его можно было добавить в ассоциативные контейнеры в качестве ключа?

    Ответ: Т.к. значения в ассоциативных контейнерах хранятся отсортированными, то объект должен реализовывать оператор сравнения <, а остальные операторы сравнения могут быть выражены через него.
    Пример:
    struct Foo
    {
        int i;
    };
    inline bool operator < (const Foo & lhs, const Foo & rhs)
    {
        return lhs.i < rhs.i;
    }
    
    std::set<Foo> data;
    Foo a, b, c;
    a.i = 7;
    b.i = 1;
    c.i = 6;
    data.insert( a );
    data.insert( b );
    data.insert( c );
    // Теперь в data элементы находятся в последовательности 1 6 7
    

    Без реализации operator < объект класса Foo нельзя было бы добавить в set, т.к. был бы не определен их порядок внутри set'а.

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

    Помимо этого, для контейнеров может быть определен класс сравнения (Comparison class), в котором будет определена логика сравнения объектов, реализованная через тот же оператор меньше.

    9. Сколько в памяти занимает произвольная структура?

    Ответ: sizeof всех членов + остаток для выравнивания (по умолчанию выравнивание 4 байта) + sizeof указателя на vtable (если есть виртуальные функции) + указатели на классы предков, от которых было сделано виртуальное наследование (размер указателя * количество классов)
    Пример:
    struct Foo
    {
        int i;
        char a;
    };
    
    int size = sizeof(Foo); // 8 байт, хотя int + char = 5. Все дело в дефолтном выравнивании равном 4, т.е. размер должен быть кратен блоку в 4 байта.
    
    // Установим выравнивание в 1 байт
    #pragma pack(push, 1)
    struct Foo
    {
        int i;
        char a;
    };
    #pragma pack(pop)
    
    int size = sizeof(Foo); // 5 байт
    

    10. Как сгенерировать pure virtual function call исключение?

    Ответ: Нужно вызвать чисто виртуальный метод в конструкторе родительского класса т.е. до создания дочернего, в котором этот метод реализован. Т.к. современный компилятор не даст это сделать напрямую, то нужно будет использовать промежуточный метод.
    Пример:
    class Base
    {
    public:
        Base()
        {
            base_func();
        }
        void base_func()
        {
            func(); // pure virtual function call exception
        }
        virtual void func() = 0;
    };
    class Derived : public Base
    {
    public:
        virtual void func()
        {
        }
    };
    

    11. В чем отличие vector от deque?

    Ответ: Здесь вспоминают о наличии у deque методов push_front и pop_front. Но основное отличие в организации памяти, у vector она как у обычного Си-массива, т.е. последовательный и непрерывный набор байт, а у deque это фрагменты с разрывами. За счет этого отличия vector всегда можно привести к обычному массиву или скопировать целиком участок памяти, но зато у deque операции вставки/удаления в начало быстрее (O(1) против O(n)), ввиду того, что не нужно перемещать остальные значения.

    12. Что дают разные модификаторы при наследовании?

    Ответ: Изменяют зону видимости членов базового класса.
    Пример:
    class Base
    {
    public:
        int i;
    };
    class Derived : private Base
    {
        // i теперь имеет модификатор доступа private
    };
    class Derived2 : private Derived
    {
    public:
        Derived2()
        {
            i = 2; // error C2247: 'Base::i' not accessible because 'Derived' uses 'private' to inherit from 'Base'
        }
    };
    
    Derived d;
    d.i; // error C2247
    

    При private наследовании protected и public члены становятся private. При protected наследовании public становится protected. А при public ничего не изменяется. Более подробно об этом Алена писала вот здесь.

    13. Что такое инкапсуляция?

    Ответ (Wiki): Инкапсуляция — свойство языка программирования, позволяющее объединить и защитить данные и код в объектe и скрыть реализацию объекта от пользователя (прикладного программиста). При этом пользователю предоставляется только спецификация (интерфейс) объекта.

    Пользователь может взаимодействовать с объектом только через этот интерфейс. Реализуется с помощью ключевого слова: public.

    Пользователь не может использовать закрытые данные и методы. Реализуется с помощью ключевых слов: private, protected.

    14. Что такое полиморфизм?

    Ответ (Wiki): Возможность объектов с одинаковой спецификацией иметь различную реализацию.
    Пример:
    class Figure 
    {
        ...
        void Draw() const;
        ...
    };
     
    class Square : public Figure 
    {
        ...
        void Draw() const;
        ...
    };
     
    class Circle : public Figure 
    {
        ...
        void Draw() const;
        ...
    };
    


    Т.е. есть базовый класс фигура, и от него унаследованы два класса квадрат и круг, имеющие собственную реализацию метода Draw().

    15. В чем отличие malloc от new?

    Ответ: malloc — выделение блока памяти в стиле Си, опасное с точки зрения приведения типов (non-typesafe), т.к. возвращает void * и требует обязательного приведения. new — выделение блока памяти и последующий вызов конструктора, безопасное с точки зрения приведения типов (typesafe), т.к. тип возвращаемого значения определен заранее.

    16. Что такое чисто виртуальный метод и абстрактный класс?

    Ответ: Чисто виртуальный метод — это метод, у которого отсутствует реализация. Абстрактный класс — это класс имеющий хотя бы один чисто виртуальный метод. Как следствие, экземпляр подобного класса не может быть создан т.к. отсутствует реализация виртуального метода.
    Пример:
    // Абстрактный класс
    class Foo
    {
    public:
        // Чисто виртуальный метод
        virtual void func() = 0;
    };
    class Bar : public Foo
    {
    public:
        virtual void func()
        {
        }
    };
    
    Foo f; // error C2259: 'Foo' : cannot instantiate abstract class	
    Bar b; // Ok
    

    17. Для чего используется вызов throw без аргументов?

    Ответ: Для повторного возбуждения предыдущего исключения и направления его следующему обработчику.
    Пример:
    try
    {
        //....
        try
        {
            // Call something
        }
        catch(const std::exception& )
        {
            // Make/Check something..
            throw; // Пересылаем исключение следующему обработчику
        }
        //...
    }
    catch(const std::exception& e)
    {
        std::cout << e.what() << std::endl;
    }
    


    18. В чем различия между delete и delete[]?

    Ответ: delete предназначен для уничтожения объектов, память под которые выделена при помощи new(). delete[] для объектов выделенных при помощи оператора new[]().
    Пример:
    class Foo
    {
    };
    
    Foo *pFoo = new Foo();
    delete pFoo;
    Foo *pFooArray = new Foo[10]();
    delete[] pFoo;
    

    При неправильном использовании оператора delete (например, delete вместо delete[]) результат будет: undefined behavior.

    19. Что стоит учитывать при использовании auto_ptr?

    Ответ: Так как данный умный указатель реализует подход разрушающего копирования, то при присвоении его другому умному указателю оригинальный потеряет свое значение. А так же его нельзя использовать в стандартных STL контейнерах.
    Пример:
    std::auto_ptr<Foo> a(new Foo);
    std::auto_ptr<Foo> b;
    b = a; // a больше не ссылается на Foo
    
    std::vector<std::auto_ptr<Foo>> v;
    v.push_back(b); // error C2558: class 'std::auto_ptr<_Ty>' : no copy constructor available or copy constructor is declared 'explicit'
    

    Также ввиду того, что в деструкторе auto_ptr вызывается оператор delete, нельзя хранить объекты созданные при помощи new[](). Именно из-за этого нюанса boost предоставляет умные указатели в двух вариантах, для просто объекта и их коллекции, например, shared_ptr и shared_array.

    20. Для чего используется ключевое слово volatile?

    Ответ: Для указания компилятору, что доступ к переменной может осуществляться из мест, неподконтрольных ему. А как следствие, что работу с данной переменной не нужно подвергать разного рода оптимизациям.
    Пример:
    volatile int i = 1; // Независимо от прочего кода, данная переменная не будет оптимизирована.
    

    Т.е. если volatile присутствует в каком-то условии, которое не меняется со временем, то компилятор может оптимизировать его, чтобы избежать ненужных проверок, при использовании volatile компилятор скорее всего не будет этого делать.
    Пример:
    while (1) 
    {
        if(i == 1)
        {
            // Какой-то код не изменяющий i
        }
    }
    
    // Если бы volatile отсутствовало, то компилятор мог бы переделать код на что-то аля:
    if(i == 1) // Нет необходимости проверять i все время, если и так известно, что оно не изменяется
    {
        while (1) 
        {
            // Какой-то код не изменяющий i
        }
    }
    


    Обновлено 24.04 в 13.35
    Поделиться публикацией
    AdBlock похитил этот баннер, но баннеры не зубы — отрастут

    Подробнее
    Реклама

    Комментарии 173

      +2
      Что такое виртуальный базовый класс?

      Меня на этом 2 раза поймали, потом наконец выучил все эти «извращения» :-) Но впрочем, на работу все равно взяли
        +4
        И вот хоть бы один написал что плохого я написал…
          0
          Я думаю ключевое слово «извращения», т.к. они самые иногда делают дизайн классов довольно удобным и легко изменяемым.
            +5
            Мне казалось, я взял это слово в кавычки именно потому что не считаю их извращениями.
              +1
              Было бы лучше, если бы не брал. :-)
                +1
                Чтобы меня ярые ценители ООП разорвали в клочья?
                  –1
                  Именно тогда бы не разорвали. 8)
            +9
            Они думают, что если они это знают, то они круче вас.
          +4
          Не хватает вопроса про виртуальное наследование и для чего оно применяется
            +1
            Пометил себе, добавлю.
              +1
              а еще «зачем нужен приватный конструктор?»
                0
                Про виртуальное наследование это уже какой-то детский сад, да и приватные конструкторы тоже. Ну не хочу я, чтобы класс вне фабрики могли создать, например!
              +8
              В чем разница между struct и class?

              Ответ: Практически ни в чем. В struct модификаторы доступа по умолчанию public, в class private.
              Это не полный ответ, продолжайте.
                +3
                Хм, кроме наследования по умолчанию, которое тоже разное: public и private, ничего в голову не приходит, оно?
                  +1
                  Оно :)
                    +1
                    :) Добавил в пост
                      0
                      Ё-моё. И зачем этот это помнить? Лично у меня RAM ограничено :)
                        +1
                        Ну если вы не пользуетесь наследованием или не ленитесь всегда писать access-specifier — то помнить, в общем то, незачем*.

                        * При условии, что вы только пишете, но не читаете код**.
                        ** Чужой код.
                          0
                          Честно говоря не очень понимаю как можно уж в этом-то случае лениться? И что, так часто приватно наследуются?
                          Вообще, наличие двух сущностей не отличающихся практически ничем — имхо бред, и лучше было бы если было бы только одно из них. И вопросов бы дурацких не было ;) и когда пишешь форвард думать не надо было бы, struct оно или class.
                            0
                            Вообще, наличие двух сущностей не отличающихся практически ничем — имхо бред
                            Это не бред, это для совместимости с Си.

                            А для форвардов и так всё равно:
                            
                            class A;
                            
                            void foo(A*);
                            
                            struct A
                            {
                                int i;
                            };
                            
                            void foo(A*)
                            {
                            }
                            Comeau, VC2010 и g++ 4.4.0 это компилируют.
                              +1
                              Да оно понятно что для совместимости, бредом от этого оно быть не перестаёт :) Зачем было растягивать сишный struct до си++ class? Оставался бы себе сишной структурой, без функций, наследования и т.п., было бы чище. А плюсовых вропперов добавлять по необходимости.
                              У меня в студии ворнинги насчёт форвардов struct/class, наверное зависит от опций.
                      0
                      Я давненько не писал на сях но, разве struct может содержать реализацию функций?
                        +1
                        В сях — не может.
                      +2
                      Тогда бонусом чем POD структура отличается от не POD.
                      +1
                      9. Сколько в памяти занимает произвольная структура?

                      Ответ: sizeof всех членов + остаток для выравнивания (по умолчанию выравнивание 4 байта) + vtable (если есть виртуальные функции)

                      9.1 Сколько в памяти занимает структура без членов?
                      struct Empty{};
                      assert(x == sizeof(Empty));
                        0
                        1 байт. Не помню почему, но есть подозрение, что размер принудительно выставляется в 1 т.к. фактически там все равно ничего нет, в просто Си, вроде, вообще нельзя объявлять пустые структуры.
                        Не подскажите в чем соль? стандарт?
                          –1
                          А случайно не равно sizeof(char)? :-)
                            –1
                            То бишь минимальная единица памяти в системе.
                              +1
                              по моему там говорится только о том что не 0
                              +2
                              sizeof(char) == 1 всегда (5.3.3/1).

                              А вот sizeof пустого класса не определён, но должен быть >0.

                              А ещё с пустыми классами есть такой забавный момент:
                              class A {};
                              class B {};
                              class C: public A, B {};

                              sizeof( C ) в этом случае может быть 1.
                            +4
                            Помогает не схватить division by zero в таких распространенных случаях

                            struct Foo{};

                              +2
                              эх. надо взять привычку писать в блокноте

                              struct Foo{};

                              Foo foo[5];
                              std::cout << sizeof(foo) / sizeof(foo[0]); // выведет 5


                              Но это так, на уровне легенды
                            0
                            Есть еще один фактор, влияющий на размер. Виртуальное наследование.

                              +2
                              class A {int a};
                              class B: virtual public A {};

                              класс B хранит int + указатель
                                +2
                                А если точнее, то размер класса увеличивается на не более чем (размер указателя)*(количество классов в иерархии наследования, у которых непосредственно есть виртуальный предок). Эти объекты хранят указатель на таблицу виртуальных классов. Для классов без членов компилятор может провести оптимизацию и уменьшить вышеприведенное значение.
                                  0
                                  Спасибо, не знал. ) Обновил.
                            +2
                            19. Что стоит учитывать при использовании auto_ptr?

                            Вы забыли про
                            std::auto_ptr p(new char[20]);
                              0
                              Спасибо, исправил.
                              –1
                              > 18. В чем различия между delete и delete[]?
                              я б добавил бы, что если будет использоваться delete вместо delete[], то будет вызван деструктор первого обьекта массива, а остальных обьектов не будет вызываться.
                                0
                                если будет использоваться delete вместо delete[], то будет вызван деструктор первого обьекта массива, а остальных обьектов не будет вызываться

                                Если delete будет применен к чему-то, что выделено с помощью new[], то behaviour is undefined. Может быть так, как вы сказали, а может быть и по-другому. Ничего не гарантируется.
                                  0
                                  Это не так
                                  habrahabr.ru/company/abbyy/blog/117208/ вот разбор полётов
                                    0
                                    на практике встречал поведение которое описал выше. Теперь буду знать, что это не единственный исход. Спасибо! :)
                                      +1
                                      5.3.5/2 если что.
                                  +3
                                  16. Что такое чисто виртуальный метод и абстрактный класс?

                                  Ответ: Чисто виртуальный метод — это метод, у которого отсутствует реализация. Абстрактный класс — это класс имеющий хотя бы один чисто виртуальный метод. Как следствие, экземпляр подобного класса не может быть создан т.к. отсутствует реализация виртуального метода.

                                  Вообще-то он не может быть создан, даже если чисто виртуальный метод будет иметь реализацию. Это, кстати, тоже хороший вопрос на собеседовании — может ли чисто виртуальный метод иметь реализацию. 70% собеседуемых почему-то отвечают «нет».
                                    0
                                    А можно подробнее про реализацию чисто виртуального метода?
                                      0
                                      Давайте вместе рассуждать.
                                      1. Может ли деструктор быть чисто виртуальным?
                                      2. Может ли объявленный деструктор не быть определён?
                                        0
                                        Может, а еще можно писать реализацию для чисто виртуальных методов и тогда она в потомках будет реализацией по умолчанию, если её не заимплементить.
                                        Скорее всего, такая байда н е слинкуется, ну или в рантайме вывалится, если повезёт.
                                          0
                                          Если в потомке чисто виртуальный метод не определить — потомок будет абстрактным классом, соответственно его даже создать нельзя будет. А вот если определить, а из него вызвать метод базового абстрактного — то всё будет ок (при условии, что он в базовом определён, конечно). Слинкуется и будет работать без выпадений.
                                            0
                                            Ну честно говоря, я особо применений этому не видел. Проще не заниматься такой магией, а то потом те, кто чуть хуже разбираются. проклянут.
                                              +1
                                              Ну как минимум — это упомянутые деструкторы. Деструктор, если объявлен, обязательно должен быть определён, иначе не слинкуемся. Другой вариант — абстрактный базовый класс, но не интерфейс, а с членами-данными. У него вполне могут быть чисто виртуальные методы работы с этими данными, которыми могут пользоваться наследники.
                                    –7
                                    Если пришедший на собеседывание не ответил на вопрос, что такое инкапсуляция или полиморфизм, или не сумел написать сортировку пузырьком — пинок под жопу и пусть катится. Не нужны такие программисты.
                                      +14
                                      Вам часто приходилось по работе писать сортировку пузырьком?
                                        –10
                                        Регулярно приходится.
                                        Не для релизного кода (там уже qsort есть), а скорее для «служебных целей».
                                        Периодичность? Ну раз в месяц наверное. Три строчки кода — проще написать заново, чем таскать либы.
                                          +12
                                          Расскажите пожалуйста, зачем нужно для служебных целей писать пузырьковую сортировку, когда в стандартной библиотеке есть qsort и std::sort? Что и куда надо таскать?
                                            +1
                                            Извините, я не указал, что я пишу на Java ME. Просто подумал, что программист, который не может написать сортировку пузырьком — это все равно что математик, забывший как считается дискриминант квадратного уравнения.
                                              0
                                              Ну это было неочевидно в контексте топика про С++. Что до пузырьковой сортировки — я не утруждаю себя запоминанием даже алгоритма её и постоянно путаю с сортировкой вставками. Позволяю я себе такое только потому, что знаю, что реализовывать мне её никогда не прийдется.

                                              А для практических заданий есть намного более раскрывающие знания задачи, чем реализация пузырьковой сортировки, которую можно тупо зазубрить.
                                                0
                                                Тут прикол в том, что не всегда быстрая сортировка является лучшим вариантом. Например, к отсортированному массиву изредка добавляется новый элемент. Куда эффективнее сделать сортировку вставкой (можно с бинарным поиском места вставки). Или если возможность применить цифровую сортировку. Или слиянием будет лучше (сортировка на распределённой системе). Поэтому «реализовывать никогда не придётся» — звучит мега странно.
                                                  0
                                                  Во-первых, «реализовывать никогда не прийдётся» относилось именно к пузырьковой сортировке. В топике задание звучит «написать пример какого-нибудь алгоритма сортировки». Какой-нибудь напишу, но это будет не пузырёк :) А началась эта ветка комментариев именно с высказывания
                                                  Если пришедший на собеседывание ... не сумел написать сортировку пузырьком — пинок под жопу и пусть катится. Не нужны такие программисты.
                                                  с которым я категорически не согласен.
                                                    +1
                                                    Ну, я тогда дополню, что правильным ответом, должен быть вопрос: что надо отсортировать, что представляет собой система, на которой надо производить сортировку. А иначе как-то странно выглядит — сортируем неизвестно что неизвестно как.

                                                    Насчёт конкретно сортировки пузырьком я тоже согласен. Но вот если программист не представляет алгоритм ни одной из сортировок. То тут действительно стоит задуматься — нужен ли он.
                                                      0
                                                      Хотя вопрос конечно тоже странный. «Какой-нибудь алгоритм сортировки» означает, что никому это не надо, а вопрос для отмашки.
                                          +2
                                          Никогда ещё не приходилось :) Всюду есть реализация быстрой сортировки.

                                          Но, сортировка пузырьком — это настолько элементарная вещь, что просто стыдно не знать.

                                          Тут даже речь не о том, чтобы что-то помнить. Главное — понять суть, а потом, когда понадобится, можно воссоздать.

                                          Если человек не утруждается пониманием основ, это говорит о поверхностных знаниях предмета. А также о том, что он не любит учиться.
                                            +1
                                            Скажу честно, пузырьковая сортировка для меня нелогична. Если простая, то напишу вставкой или выбором — намного более понятные с точки зрения логики. А пузырёк, наверное проще зубрится. А так вообще есть прекрасные алгоритмы быстрой сортировки и деревом. Да, лично мне быструю написать (с нуля) проще, чем пузырёк.
                                      • НЛО прилетело и опубликовало эту надпись здесь
                                          +1
                                          12. Что дают разные модификаторы при наследовании?
                                          Ответ: Изменяют зону видимости членов базового класса.


                                          Более точный ответ: изменяют зону видимости интерфейса базового класса (а не только членов).
                                          То бишь, при private наследовании только объекты дочернего класса знают о функционале базового класса (public и protected членах/методах), при protected — информация распостраняется и дальше при наследовании, при public наследовании интерфейс базового класса становится доступен за пределами объекта (только public члены/методы). Это же правило распостраняется на преобразование к базовому классу (static_cast<>).
                                          И, если не считать виртуальных методов, private/protected наследование мало чем отличается от обычного private/protected члена.
                                            0
                                            3. Для каких целей применяется ключевое слово const?

                                            Ответ:
                                            Позволяет задать константность объекта
                                            Позволяет задать константность указателя
                                            Позволяет указать, что данный метод не модифицирует члены класса, т.е. сохраняет состояние объекта

                                            Спецификатор const означает «только для чтения».

                                            Думаю, будет полезно ещё почитать статью на http://chipenable.ru. Там вопросы по Си, но для С++ тоже можно почерпнуть.
                                              0
                                              Атас. Всё, что мы обычно спрашиваем. Ещё кое-что:

                                              Почему basic_string не имеет оператора приведения типа к
                                                 operator const value_type *() const;
                                              
                                              а вместо этого есть:
                                              <source lang="cpp">
                                                  const value_type *c_str( ) const;
                                                +2
                                                6. Как защитить объект от копирования?

                                                Ответ: Сделать private конструктор копирования и оператор =.
                                                Так вы защититесь только от копирования извне, но сможете копировать в членах класса. Нужно не просто делать их приватными, но ещё и оставлять без реализации.
                                                  +2
                                                  А потом добрый дядя в любом cppшнике накатает реализацию ;)
                                                    +1
                                                    6. Как защитить объект от копирования?

                                                    Ответ: Сделать private конструктор копирования и оператор =.

                                                    Так вы защититесь только от копирования извне, но сможете копировать в членах класса. Нужно не просто делать их приватными, но ещё и оставлять без реализации.


                                                    В членах и friend'ах.
                                                    0
                                                    > 10. Как сгенерировать pure virtual function call исключение?

                                                    Граблями по лбу! А вот расскажите как сделать так, чтобы обойти эту проблему, а? ;)

                                                    Ещё сколько раз твердили миру, что исключения в конструкторах и деструкторах это злоЪ. Если я хочу породить объект он должен обязательно создаться и если я хочу его убить, он должен убиться. А уж будет ли он валидным — это другой вопрос.
                                                      +2
                                                      Это вечный холивар. Если вы не хотите создавать объект в два этапа — иначе как бросив исключение из конструктора об ошибке не сообщишь. Ничего плохого в выбрасывании исключений из конструктора нету, если писать exception-safe код.
                                                        0
                                                        И в общем то «pure virtual function call исключение» — это не С++ исключение, которое вы не любите бросать из конструкторов. В случае pure virtual function call будет UB, обычно это аварийное завершение программы.
                                                          0
                                                          Знамо как обойти эту проблему — вызывать всякий стрёмный код из методов Initialize(). Вот только их нужно не забывать вызывать да во всех остальных методах проверять, был вызван Initialize() или нет. Ну или не исключения бросать в конструкторе, а выставлять какой-нибудь флаг в FAIL и разными getlasterror() его проверять. Первый подход использует COM, второй — iostream. И там и там свои плюсы и минусы.
                                                            0
                                                            а если не хочется методов типа initialize? Точнее не хочется вызывать их извне. Тут работает штука типа QTimer::singleShot(this, 0, SLOT(myTrueInit()); Впрочем тут грабля в том, что если сразу начать юзать класс, то он до следующего прохода по цепочки событий будет неполноценным.
                                                            +2
                                                            Миру твердят про деструкторы только, пускать исключения из конструктора это вопрос стиля и однозначного мнения по этому поводу нет. Т.к. исключение в конструкторе не может натворить того, что может натворить исключение в деструкторе.
                                                          • НЛО прилетело и опубликовало эту надпись здесь
                                                              0
                                                              переопределить new и закрыть конструктор в private?
                                                              • НЛО прилетело и опубликовало эту надпись здесь
                                                                  0
                                                                  typedef Foo void?
                                                                  • НЛО прилетело и опубликовало эту надпись здесь
                                                                      0
                                                                      Скрыть деструктор? Тогда delete придется перегружать — хрен редьки не слаще.
                                                                      • НЛО прилетело и опубликовало эту надпись здесь
                                                                          +2
                                                                          Речь о том, что на предложение закрыть конструктор и переопределить new вы сказали, что нет, все проще. А на самом деле ваше решение не проще — хрен редьки не слаще.
                                                                          +2
                                                                          Деструктор скрыть. А для уничтожения добавить открытый метод destroy, который и вызовет этот деструктор «изнутри».
                                                                            +2
                                                                            class HeapOnly
                                                                            {
                                                                            public:
                                                                            	void destroy() { delete this; };
                                                                            private:
                                                                            	~HeapOnly() {};
                                                                            };
                                                                  0
                                                                  Сделать приватный деструктор?
                                                                    +2
                                                                    Обновляй комментарии, зараза!
                                                                  +7
                                                                  Из странного… :)
                                                                  А вот это скомпилируется?
                                                                  long static int long unsigned const __w64 zzz;
                                                                  А почему?
                                                                    0
                                                                    Неплохой вопрос на знание никому не нужных особенностей C++ и внимания к инициализации — вот это действительно нужно. А __w64 лишнее. Оно и в VC уже deprecated, а уж GCC его и в помине не знает.
                                                                    0
                                                                    2. Что стоит помнить при использовании исключений в конструкторе объекта?

                                                                    Я бы еще добавил, что деструкторы будут вызваны для всех созданных членов класса.
                                                                      0
                                                                      А я бы ещё добавил, что из деструкторов не рекомендуется выбрасывать исключения наружу, хоть это формально и не запрещено. Потому что если такой деструктор вызовется при раскрутке стека, а в нём выбросится ещё одно исключение — вызовется terminate.
                                                                      +2
                                                                      еще многие не знают, чем C от C++ отличается. может имеет смысл поспрашивать? Думают, что только классы появились. Об отличиях в структурах или объявлении переменных не догадываются.
                                                                        +2
                                                                        А как же мясо с указателем на void? :-) В С++ типизация более строгая.
                                                                          0
                                                                          да-да, отличий куда больше чем «просто добавились классы», об этом же и речь.
                                                                          0
                                                                          Один из вопросов в плане отличий — напишите программу на С, которая не скомпилируется компилятором С++. K&R style parameters не считаются — это рудимент даже в С.
                                                                            +10
                                                                            int class;
                                                                              +2
                                                                              // main.c
                                                                              
                                                                              main()  /* poor style C. Not C++ */
                                                                              {
                                                                              double sq2 = sqrt(2);                         /* call undeclared function */
                                                                              printf("the square root of 2 is %g\n", sq2);  /* call undeclared function */
                                                                              }
                                                                              
                                                                                0
                                                                                Найдёте 2-е ошибки?
                                                                                  0
                                                                                  Они ж подписаны? Или там кроме них есть ещё 2 ошибки?
                                                                                    0
                                                                                    Подписаны C/C++ incompatibilities. Этот код компилируется С99 компилятором, но содержит 2-е ошибки. Чем не вопрос на собеседовании?
                                                                                      0
                                                                                      Я, честно говоря, С знаю плохо. Сначала я думал, что ошибки в том, что для необъявленных функций будет работать правило implicit int, но я скомпилировал и корень посчитался и вывелся верно. Если собирать с --std=c89, то программа возвращает не 0, это тоже можно считать ошибкой. Но с --std=c99 возвращается 0, так что я даже не знаю.
                                                                          0
                                                                          Не поправка, но добавление к 20.

                                                                          При упоминании volatile чаще всего вспоминают многопоточность. Яркий пример — из одного потока отслеживается состояние некого объекта/флага/переменной другого потока.
                                                                            0
                                                                            А также если периферия пишет в данный участок памяти, то значение volatile переменной может меняться извне. Volatile подсказывает компилятору не делать предположений о текущем значении переменной (а значит — и не применять оптимизацию)
                                                                              0
                                                                              Volatile и многопоточность — не очень хорошая практика. По крайней мере в C++. Для многопоточности есть специальные высокоуровневые примитивы, в частности atomic.
                                                                              +8
                                                                              11. В чем отличие vector от deque?

                                                                              но зато у deque операция вставки в произвольное место быстрее (O(1) против O(n)), ввиду того, что не нужно перемещать остальные значения.


                                                                              Неверно. Дек имеет АМОРТИЗИРОВАННОЕ константное время вставки/удаления только в начало и конец (а не в произвольное место — этим отличается от листа). Это легче понять, если вспомнить, что наиболее частая реализация дека, отвечающая требованиям стандарта, — кольцевой буфер.

                                                                              20. Для чего используется ключевое слово volatile?
                                                                              Ответ: Для указания компилятору о том, что данную переменную не нужно оптимизировать.


                                                                              Неверно. Это указание компилятору, что доступ к переменной может осуществляться из мест, неподконтрольных ему. Одно из следствий — запрет размещения в регистрах, перевыделения памяти под другие переменные и части других оптимизаций (но не запрет оптимизации вообще). Другое, менее известное следствие — помимо подавления неупорядоченного выполнения (out-of-band execution) на уровне компилятора, компилятор предпринимает усилия для подавления такого выполнения и на уровне процессора тоже (вставкой memory barrier-ов).
                                                                                0
                                                                                >Дек имеет АМОРТИЗИРОВАННОЕ константное время вставки/удаления только в начало и конец (а не в произвольное место

                                                                                — Было дело, реализовывали дек на основе плавающего массива. Добавление в произвольное место — логарифм.
                                                                                  0
                                                                                  Спасибо.
                                                                                  Подправил часть про сложность у дек и оптимизацию у volatile.
                                                                                  Про volatile понял, что нужно будет мне еще почитать, т.к. чувствую что тема сложнее чем мне казалось.
                                                                                  +11
                                                                                  Такая же статья по питону кому-то нужна?
                                                                                    –9
                                                                                    А по С++ нужна была? Спорный вопрос, забивание памяти какими-то тонкостями не даст понимания, не заменит опыта
                                                                                      +7
                                                                                      Да почему «тонкостями»-то?.. Что за отношение к программированию?

                                                                                      Вы мне напоминаете студентов ВУЗа, с которыми я, учась в своем ВУЗе, ну, скажем так, «конкурировал». Они на любой практический вопрос любили отвечать «Ой, да зачем это знать? Нас учат учиться. Захотим — узнаем», при этом большинство из них так ничего и не узнали ни тогда, ни позже.

                                                                                      Это далеко не тонкости, не трюки, обычные вопросы, не сложные. Любой человек, который пишет(не знает в совершенстве, а просто пишет) программы на С++ должен знать на них ответы.
                                                                                        +5
                                                                                        Ок, я переубежден. Хороший топик.
                                                                                          0
                                                                                          Другой вопрос — если человек «вызубрит» такие вопросики — станет ли он от этого хорошим программистом?
                                                                                          Да и ответы в топике иногда странные. Выглядят как выученные фразы, а не понимание.
                                                                                            0
                                                                                            Задача собеседования как раз отличить одних программистов от других…
                                                                                        +16
                                                                                        Да.
                                                                                          0
                                                                                          Да!
                                                                                        • НЛО прилетело и опубликовало эту надпись здесь
                                                                                            –4
                                                                                            Очень интересно.
                                                                                            Хотелось бы прочитать / написать подобное для Delphi.
                                                                                              0
                                                                                              будет очень популярно, чую
                                                                                              0
                                                                                              Если есть вопрос про volatile, почему нет про explicit или mutable? :)
                                                                                                0
                                                                                                Пометил написать об explicit. Про mutable есть в вопросе номер 3.
                                                                                                  0
                                                                                                  Извиняюсь, я по верхам пробежался. Смотрел преимущественно сами вопросы, поэтому проглядел :)
                                                                                                +2
                                                                                                9. Сколько в памяти занимает произвольная структура?

                                                                                                Ответ: sizeof всех членов +… + vtable (если есть виртуальные функции) +…


                                                                                                Неправильно. За этим обычно следует вопрос: «Так что, получается, каждый объект от класса с виртуальными методами имеет свою собственную копию vtable?»
                                                                                                  0
                                                                                                  Хм… ну логично, как и смещения для методов, зачем их то дублировать для каждого экземпляра класса. Эти же смещения и есть вроде как указатели на методы-члены класса.
                                                                                                    0
                                                                                                    должно быть sizeof всех членов +… + sizeof указателя(наvtable (если есть виртуальные функции)) +…
                                                                                                      0
                                                                                                      Спасибо, исправил.
                                                                                                      +6
                                                                                                      8. Каким свойством должен обладать объект, чтобы его можно было добавить в ассоциативные контейнеры в качестве ключа?

                                                                                                      Ответ: Т.к. значения в ассоциативных контейнерах хранятся отсортированными, то объект должен реализовывать оператор сравнения <, а остальные операторы сравнения могут быть выражены через него.


                                                                                                      Не обязательно, можно передать функтор, реализующий оператор < в качестве второго (в случае std::set) шаблонного параметра.
                                                                                                        0
                                                                                                        Да, это более полный ответ, добавил к вопросу. Спасибо.
                                                                                                        +3
                                                                                                        На нескольких собеседованиях спрашивали вопрос, что выведет:
                                                                                                        int i = 5;
                                                                                                        printf( "%d,%d", ++i, ++i );

                                                                                                        Правильный ответ естественно undefined behavior.
                                                                                                        +1
                                                                                                        Интересно просто почитать, для развития. Спасибо!
                                                                                                          0
                                                                                                          Ответ: sizeof всех членов + остаток для выравнивания (по умолчанию выравнивание 4 байта) + vtable (если есть виртуальные функции) + указатели на классы предков, от которых было сделано виртуальное наследование (размер указателя * количество классов)

                                                                                                          На самом деле vtable не создается для каждого экземпляра класса. Объекты одного и того же типа ссылаются на одну и ту же vtable. Конкретный экземпляр имеет ссылку на эту таблицу.
                                                                                                            0
                                                                                                            class NoCopybale
                                                                                                            правильно — Copyable
                                                                                                              0
                                                                                                              Спасибо, исправил.
                                                                                                              +2
                                                                                                              Меня просили рассказать о процессе компиляции, линковки (как можно ускорить/замедлить их), о порядке инициализации статических переменных и членов класса.
                                                                                                                +1
                                                                                                                > 19. Что стоит учитывать при использовании auto_ptr?

                                                                                                                Стоит учитывать, что он deprecated и если вам можно использовать C++11, то нужно использовать std::unique_ptr и std::shared_ptr, которые могут работать с массивами, так как позволяют указывать deleter.

                                                                                                                > 6. Как защитить объект от копирования?
                                                                                                                > Ответ: Сделать private конструктор копирования и оператор =.

                                                                                                                Верно, но в C++11 можно красивее: см. deleted member functions.
                                                                                                                  +3
                                                                                                                  Ответ на первый вопрос уже порадовал, он довольно глуп и я бы такого человека уже не взял на работу, это явно ему просто сказали и все, и этот человек не особо понимает смысла сей конструкции.

                                                                                                                  Все же виртуальный деструктор нужен для того, чтобы был вызван нужный деструктор, а не деструктор класса к которому был приведен указатель на объект, соответственно и вся цепочка деструкторов следуя наследованию. Да и объяснив что такое виртуальность было бы пользы в разы больше :)
                                                                                                                    +1
                                                                                                                    Стоило бы рассмотреть оператор new (*memory) className; частенько при использовании менеджеров памяти требуется.
                                                                                                                    • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                        0
                                                                                                                        Спасибо, подправил.
                                                                                                                        0
                                                                                                                        И ещё, не обратил внимание: как это у нас сортировка делается без доп переменной? Хотите сказать, что в std::swap она не порождается?
                                                                                                                          0
                                                                                                                          Имелось ввиду, что в мое коде не используется. В std::swap конечно же есть.
                                                                                                                          А вообще для простых типов можно было бы написать полностью свободный от временных переменных алгоритм через XOR.
                                                                                                                            0
                                                                                                                            Это когда регистров жалко! А в тех областях, где на плюсах прогают, их обычно хватает!
                                                                                                                              0
                                                                                                                              В обмене без дополнительной переменной через xor тоже, кстати, часто делают ошибку.
                                                                                                                                0
                                                                                                                                Какую?
                                                                                                                                  +1
                                                                                                                                  Вот такую:
                                                                                                                                  void swap(int& x, int& y)
                                                                                                                                  {
                                                                                                                                      x^=y^=x^=y;
                                                                                                                                  }

                                                                                                                                  Сэкономили 2 строчки, зато получили UB.
                                                                                                                                    0
                                                                                                                                    Хехе, это, видимо, те же самые люди, что придумали:
                                                                                                                                    int i = 1;
                                                                                                                                    i = i++ + i + ++i;
                                                                                                                                    
                                                                                                                                      0
                                                                                                                                      Ну кто мог написать i = i+++i+++i; в здравом уме, я представить не могу.
                                                                                                                                      А своп такой придумать — вполне. Красивее ведь, чем в 3 строчки, а про sequence points не все в курсе.
                                                                                                                                        0
                                                                                                                                        Ну в примере с xor-ом то UB не из-за порядка операций, а в случае (&x==&y)
                                                                                                                                          0
                                                                                                                                          UB в любом случае, даже если &x != &y.

                                                                                                                                          5/4:
                                                                                                                                          Between the previous and next sequence point a scalar object shall have its stored value modified at most once by the evaluation of an expression. Furthermore, the prior value shall be accessed only to determine the value to be stored.
                                                                                                                              +3
                                                                                                                              Вот на собеседованиях по плюсам ненавижу вопросы, где в одну строчку автор выписывает выражение без скобок со всеми известными ему операторами и надо сказать, что при этом получится. Оно, конечно, понятно, что приоритет операций и все такое, но в качестве ответа всегда хочется сказать, что автора подобного кода надо успеть закопать до того, как он успеет наплодить его многие килобайты.
                                                                                                                                +3
                                                                                                                                Так может собеседующий и ждет от вас ответа, что такой код лучше не писать?:)
                                                                                                                                0
                                                                                                                                Есть еще довольно известный список вопросов вот здесь. Без ответов правда.
                                                                                                                                  +1
                                                                                                                                  Видел этот список, популярным его назвать сложно, а я хотел собрать именно популярные вопросы. )
                                                                                                                                  +1
                                                                                                                                  В вашем примере пункта #14 полиморфизма нет. Есть method overriding.
                                                                                                                                    –1
                                                                                                                                    Полиморфизм бывает статический и динамический. У меня пример первого, а вы имеете ввиду второй.
                                                                                                                                      +2
                                                                                                                                      Статический полиморфизм или compile-time polymorphism это то, что предлагают шаблоны функций/классов (class/function templates).
                                                                                                                                        0
                                                                                                                                        это то, что предлагают шаблоны функций/классов (class/function templates).

                                                                                                                                        Почему вы решили, что только они? Можете дать ссылку на какой-то стандарт?
                                                                                                                                        Вот вы упомянули method overriding, а я вот думаю, что это тоже полиморфизм, одна из ее разновидностей. Или вы не согласны с этим? Если не согласны дайте определение полиморфизму желательно подкрепленное чем-нибудь.
                                                                                                                                          0
                                                                                                                                          In computer science, polymorphism is a programming language feature that allows values of different data types to be handled using a uniform interface.



                                                                                                                                          1. Ad-hoc polymorphism: If the function denotes different and potentially heterogeneous implementations depending on a limited range of individually specified types and its combination, it is called ad-hoc polymorphism. Ad-hoc polymorphism is supported in many languages using function and method overloading.

                                                                                                                                          2. Parametric polymorphism: If all code is written without mention of any specific type and thus can be used transparently with any number of new types, it is called parametric polymorphism.

                                                                                                                                            In the object-oriented programming community, programming using parametric polymorphism is often called generic programming.

                                                                                                                                          3. Subtype polymorphism: In object-oriented programming, subtype polymorphism or inclusion polymorphism is a concept in type theory wherein a name may denote instances of many different classes as long as they are related by some common super class.


                                                                                                                                          http://en.wikipedia.org/wiki/Polymorphism_(computer_science)
                                                                                                                                            –1
                                                                                                                                            Т.е. что в ссылке приведенной вами есть method overloading вас не смущает, а method overriding смущает? Вы же написали, что method overriding это не полиморфизм.

                                                                                                                                            Ладно. Итого, я считаю, т.к. в стандарте нет точно описания, что можно считать полиморфизмом, а что нет, все рассуждения на эту тему высказывание собственного мнения, которое не может считаться конечной инстанцией.
                                                                                                                                              +1
                                                                                                                                              Вы не видите разницы между method overloading и method overriding?

                                                                                                                                              Не изображайте из себя жертву: если на то пошло, то я высказываю не собственное «мнение», а «мнение» Christopher Strachey, John Reynolds, и иже с ними. Признавать или не признавать их идеи — ваше право. Однако используя общепринятую терминологию в собственных целях вы вводите людей в заблуждение и только.
                                                                                                                                              0
                                                                                                                                              Раз уж Вы решили мериться ссылками на wiki, то вот — en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming#C.2B.2B А вообще как мне представляется, override — это и есть Parametric polymorphism.
                                                                                                                                      +2
                                                                                                                                      Когда нельзя кидать исключение и почему? (нельзя из деструктора, так невозможно будет написание кода, удовлетворяющего базовой гарантии… эээ как это по-русски… юезопасности исключений? basic exception-safety guarantee — что-то типа того)

                                                                                                                                      ну и собственно какие гарантии безовасности исключений известны, какие гарантируются контейнерами STL и т.п.

                                                                                                                                      на виндах и юниксе интересно спросить про разницу в реализации catch(...)

                                                                                                                                      Какие бывают виды оператора new()? (интересен главным образом placement new)
                                                                                                                                        0
                                                                                                                                        Ни пузырёк, ни переворот строки не компилируется в g++ 4.4 (expected ‘;’ before ‘i’).

                                                                                                                                        На момент разбора компилятор не видит различий между членами класса и типами, определёнными в нём. То есть, надо писать typename T::size_type в 4-х местах.

                                                                                                                                        Более подробно об использовании typename.
                                                                                                                                          0
                                                                                                                                          Всё верно, но в некоторых случаях компилятор может «умничать» и предполагать. Например в VS2008 это компилируется без typename.
                                                                                                                                          +1
                                                                                                                                          Про инкапсуляцию я бы сказал, что это один из основных инструментов управления сложностью, позволяющий опустить детали реализации и оперировать на другом уровне. Инкапсуляция не обязательно может быть в объекте, она может быть в пакете, например.
                                                                                                                                            0
                                                                                                                                            Прекрасный вопрос, на который я однажды попался: «Как сравнить две переменные типа double или float на равенство?» — взят отсюда easy-coding.blogspot.com/2011/01/blog-post_7753.html
                                                                                                                                              –2
                                                                                                                                              Популярные вопросы на собеседовании по Ruby и ответы на них

                                                                                                                                              5. Можете ли вы написать код для переворота строки?
                                                                                                                                              str.reverse


                                                                                                                                              Странный язык этот С++. Сколько лет ему, а вопросы все те же – развернуть строку, и что главное, решение становится все сложней и сложней!..
                                                                                                                                                0
                                                                                                                                                В C++ тоже можно написать std::reverse(str.begin(), str.end()), но задачи на переворот строки задают с другой целью.
                                                                                                                                                0
                                                                                                                                                Вот еще часто задают:
                                                                                                                                                В чем отличия между указателем и ссылкой?

                                                                                                                                                Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.

                                                                                                                                                Самое читаемое