Виклик конструкторів в c ++ без нових

Я часто бачив, що люди створюють об’єкти в C ++ за допомогою

Thing myThing("asdf");

Замість цього:

Thing myThing = Thing("asdf");

Це, здається, працює (використовуючи gcc), принаймні до тих пір, поки немає шаблонів. Моє запитання зараз, чи правильний перший рядок, і якщо так, чи слід його використовувати?

Обидва рядки насправді правильні, але роблять тонко різні речі.

Перший рядок створює новий об'єкт у стеку, викликаючи конструктор формату Thing(const char*).

Другий - трохи складніший. Він по суті робить наступне

1. Створіть об’єкт типу Thingза допомогою конструктораThing(const char*)
2. Створіть об’єкт типу Thingза допомогою конструктораThing(const Thing&)
3. Зателефонуйте ~Thing()на об’єкт, створений на кроці №1

Я припускаю, що з другого рядка ви насправді маєте на увазі:

Thing *thing = new Thing("uiae");

який був би стандартним способом створення нових динамічних об'єктів (необхідних для динамічного зв’язування та поліморфізму) та зберігання їх адреси до вказівника. Ваш код виконує те, що описав JaredPar, а саме створить два об'єкти (один пройшов a const char*, другий пройшов a const Thing&), а потім викликає деструктор ( ~Thing()) на перший об'єкт (той const char*).

Навпаки, це:

Thing thing("uiae");

створює статичний об'єкт, який автоматично руйнується при виході з поточної області.

Компілятор цілком може оптимізувати другу форму в першу форму, але цього не потрібно.

#include <iostream>

class A
{
    public:
        A() { std::cerr << "Empty constructor" << std::endl; }
        A(const A&) { std::cerr << "Copy constructor" << std::endl; }
        A(const char* str) { std::cerr << "char constructor: " << str << std::endl; }
        ~A() { std::cerr << "destructor" << std::endl; }
};

void direct()
{
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
    A a(__FUNCTION__);
    static_cast<void>(a); // avoid warnings about unused variables
}

void assignment()
{
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
    A a = A(__FUNCTION__);
    static_cast<void>(a); // avoid warnings about unused variables
}

void prove_copy_constructor_is_called()
{
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
    A a(__FUNCTION__);
    A b = a;
    static_cast<void>(b); // avoid warnings about unused variables
}

int main()
{
    direct();
    assignment();
    prove_copy_constructor_is_called();
    return 0;
}

Вихід від gcc 4.4:

TEST: direct
char constructor: direct
destructor

TEST: assignment
char constructor: assignment
destructor

TEST: prove_copy_constructor_is_called
char constructor: prove_copy_constructor_is_called
Copy constructor
destructor
destructor

Простіше кажучи, обидва рядки створюють об'єкт на стеці, а не на купі, як це робиться у «новому». Другий рядок насправді передбачає другий виклик конструктору копій, тому його слід уникати (його також потрібно виправити, як зазначено в коментарях). Ви повинні використовувати стек для невеликих об'єктів якомога більше, оскільки це швидше, однак якщо ваші об'єкти виживуть довше, ніж кадр стека, це очевидно неправильний вибір.

В ідеалі компілятор оптимізував би другий, але це не потрібно. Перший - найкращий спосіб. Однак, досить важливо зрозуміти різницю між стеком і купами в C ++, тому що ви повинні керувати власною пам’яттю купи.

Я трохи пограв з цим, і синтаксис здається досить дивним, коли конструктор не бере аргументів. Наведу приклад:

#include <iostream> 

using namespace std;

class Thing
{
public:
    Thing();
};

Thing::Thing()
{
    cout << "Hi" << endl;
}

int main()
{
    //Thing myThing(); // Does not work
    Thing myThing; // Works

}

тому просто записування дужок myThing без дужок фактично викликає конструктор, тоді як Thing myThing () робить компілятор тим, що ви хочете створити вказівник функції чи щось таке !!

У додаток до відповіді JaredPar

1-звичайний ctor, 2-х функціональний-ctor з тимчасовим об'єктом.

Складіть це джерело десь тут http://melpon.org/wandbox/ з різними компіляторами

// turn off rvo for clang, gcc with '-fno-elide-constructors'

#include <stdio.h>
class Thing {
public:
    Thing(const char*){puts(__FUNCTION__ );}
    Thing(const Thing&){puts(__FUNCTION__ );}   
    ~Thing(){puts(__FUNCTION__);}
};
int main(int /*argc*/, const char** /*argv*/) {
    Thing myThing = Thing("asdf");
}

І ви побачите результат.

Від ISO / IEC 14882 2003-10-15

8.5, частина 12

Ваша 1-я, 2-я конструкція називається прямою ініціалізацією

12.1, частина 13

Перетворення типу функціональних позначень (5.2.3) може використовуватися для створення нових об'єктів такого типу. [Примітка: Синтаксис виглядає як явний виклик конструктора. ] ... Об'єкт, створений таким чином, не називається. [Примітка: 12.2 описується термін експлуатації тимчасових об'єктів. ] [Примітка: явні виклики конструктора не дають значення, див. 3.10. ]

Де читати про RVO:

12 Спеціальні функції членів / 12.8 Копіювання об'єктів класу / Частина 15

Коли певні критерії виконуються, реалізація допускається опускати конструкцію копії об’єкта класу, навіть якщо конструктор копії та / або деструктор для об'єкта мають побічні ефекти .

Вимкніть його з прапорцем компілятора з коментаря, щоб переглянути таке поведінку копіювання)