Как заставить компилятор использовать явный конструктор копирования?

Question

Я написал небольшую тестовую программу с классом образцов, содержащую также самоопределяемый конструктор, деструктор, конструктор копирования и оператор присваивания. Я был удивлен, когда я понял, что конструктор копирования не был вызван вообще, хотя я реализовал функцию со значениями возвратных моего класса и линии, как Object o1; Object o2(o1);

innerclass.hpp:

#include <iostream> 

class OuterClass 
{ 
public: 
OuterClass() 
{ 
    std::cout << "OuterClass Constructor" << std::endl; 
} 
~OuterClass() 
{ 
    std::cout << "OuterClass Destructor" << std::endl; 
} 
OuterClass(const OuterClass & rhs) 
{ 
    std::cout << "OuterClass Copy" << std::endl; 
} 
OuterClass & operator=(const OuterClass & rhs) 
{ 
    std::cout << "OuterClass Assignment" << std::endl; 
} 

class InnerClass 
{ 
public: 
    InnerClass() : m_int(0) 
    { 
     std::cout << "InnerClass Constructor" << std::endl; 
    } 
    InnerClass(const InnerClass & rhs) : m_int(rhs.m_int) 
    { 
     std::cout << "InnerClass Copy" << std::endl; 
    } 
    InnerClass & operator=(const InnerClass & rhs) 
    { 
     std::cout << "InnerClass Assignment" << std::endl; 
     m_int = rhs.m_int; 
     return *this; 
    } 
    ~InnerClass() 
    { 
     std::cout << "InnerClass Destructor" << std::endl; 
    } 
    void sayHello() 
    { 
     std::cout << "Hello!" << std::endl; 
    } 

private: 
    int m_int; 
}; 

InnerClass innerClass() 
{ 
    InnerClass ic; 
    std::cout << "innerClass() method" << std::endl; 
    return ic; 
} 
}; 

innerclass.cpp:

#include "innerclass.hpp" 

int main(void) 
{ 
std::cout << std::endl << "1st try:" << std::endl; 


OuterClass oc; 
OuterClass oc2(oc); 
oc.innerClass().sayHello(); 

std::cout << std::endl << "2nd try:" << std::endl; 

OuterClass::InnerClass ic(oc.innerClass()); 
ic = oc.innerClass(); 
} 

Выход:

1st try: 
OuterClass Constructor 
OuterClass Copy 
InnerClass Constructor 
innerClass() method 
Hello! 
InnerClass Destructor 

2nd try: 
InnerClass Constructor 
innerClass() method 
InnerClass Constructor 
innerClass() method 
InnerClass Assignment 
InnerClass Destructor 
InnerClass Destructor 
OuterClass Destructor 
OuterClass Destructor 

я прочитал, что нет гарантии, что компилятор будет использовать явно определенный конструктор копирования. Я не понимаю этого поведения. Почему конструктор копирования даже существует тогда, если мы не знаем, что он называется? Как компилятор решает, использует ли он его?

Или, еще лучше, есть ли способ заставить компилятор использовать самоопределяемый конструктор копирования?

Answer 1

Просто для полноты с другими ответами, стандарт позволяет компилятор опускает копию конструктор в определенных ситуациях (другие ответы называются «Оптимизация возвращаемых значений» или «Оптимизация с наименьшими возвращаемыми значениями» - RVO/NRVO):

12.8 объектов класса Копирование, пункт 15 (C++ 98)

Всякий раз, когда объект временного класса копируется с помощью конструктора копирования, и этот объект и копия имеют тот же CV-неквалифицированным типа, является реализация разрешено обрабатывать оригинал и копию как два разных способа обращения к одному и тому же объекту и вообще не выполнять копию, даже если конструктор или деструктор экземпляра класса имеют побочные эффекты. Для функции с возвращаемым типом класса, если выражение в операторе return является именем локального объекта, а cv-неквалифицированный тип локального объекта совпадает с типом возвращаемой функции, реализации разрешено опускать создание временный объект для хранения возвращаемого значения функции, даже если конструктор или деструктор экземпляра класса имеет побочные эффекты. В этих случаях объект уничтожается в более поздние моменты, когда оригинал и копия были бы уничтожены без оптимизации.

Так что в вашем методе innerClass(), конструктор копирования можно подумать, будет называться по возвращении разрешается оптимизировать расстояние:

InnerClass innerClass() { 
    InnerClass ic; 
    std::cout << "innerClass() method" << std::endl; 
    return ic; // this might not call copy ctor 
} 

Answer 2

Вы не должны проектировать свой класс с опорой на конструктор копирования, вызываемый (или не вызываемый) при определенных обстоятельствах. Компилятору разрешено удалять или добавлять вызовы конструктора вызовов во всевозможные места, и вы действительно не хотите отслеживать их.

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

Answer 3

Object o1(); не создает никаких объектов, а определяет прототип функции с именем функции o1, void arguments и возвращаемым типом как объект. Вам нужно опубликовать код, чтобы найти актуальную проблему.

Answer 4

Я согласен с Нилом, вы не должны писать класс, который зависит от вызываемого конструктора копии. А именно потому, что компилятор может делать такие вещи, как «Именованная оптимизация возвращаемых значений» (link), которая полностью избегает конструктора копирования во многих сценариях возвращаемого значения. Чтобы принудительно вызвать конструктор копирования, вам нужно написать много кода, предназначенного для «обмана» компилятора C++. Не хорошая идея.

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

Object SomeFunc() { 
    Object o1 = ... 
    return Object(o1); 
} 

Answer 5

Опубликовать код. Я думаю, вы используете неправильный синтаксис.

Конструктор копирования должен точно иметь следующую подпись:

MyObject(const MyObject&) 

Затем вы можете увидеть, если конструктор копирования вызывается с помощью следующего кода:

MyObject m1; 
MyObject m2(m1); 

Вы не разрешается использовать MyObject m1(); это объявление функции.

Answer 6

В этом проблема?

OuterClass(const OuterClass & rhs) 
{   
std::cout << "OuterClass Constructor" << std::endl; 
==> 
std::cout << "OuterClass Copy Constructor" << std::endl; 

} 

OuterClass & operator=(const OuterClass & rhs) 
{  
std::cout << "OuterClass Constructor" << std::endl; 
==> 
std::cout << "OuterClass Assignment operator" << std::endl; 
} 

Ошибка копирования в пачку!

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

EDIT: для внутреннего выпуска класса:

Как и другие уже отмечали это дело Имя Возвращаемое значение оптимизации (NRVO).

InnerClass innerClass() 
{  
    InnerClass ic;   
    std::cout << "innerClass() method" << std::endl;   
    return ic; 
} 

компилятор может трансформирует функцию

void innerClass(InnerClass &namedResult) 

{ 
std::cout << "innerClass() method" << std::endl; 

} 

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

Перейди через ниже две ссылки, чтобы понять больше на NRVO:

• MSDN NRVO
• Stan Lippman's BLog