복사 생성자 초기화 목록

Question

초기화되지 않은 생성자의 초기화 목록에서 멤버를 제외하면 해당 멤버의 기본 생성자가 호출된다는 것을 알고 있습니다.

복사 생성자는 마찬가지로 구성원의 복사 생성자를 호출합니까? 아니면 기본 생성자를 호출합니까?

class myClass { 
    private: 
    someClass a; 
    someOtherClass b; 
    public: 
    myClass() : a(DEFAULT_A) {} //implied is b() 
    myClass(const myClass& mc) : a(mc.a) {} //implied is b(mc.b)??? or is it b()? 
} 

Answer 1

명시 적으로 정의 된 복사본 생성자는 멤버에 대한 복사본 생성자를 호출하지 않습니다.

생성자의 본문을 입력하면 해당 클래스의 모든 멤버가 초기화됩니다. 즉, {에 도착하면 모든 구성원이 초기화되었음을 보증하게됩니다.

지정되지 않은 한 멤버는 클래스에 나타나는 순서대로 기본 초기화됩니다. (그렇게 할 수 없다면 프로그램은 부적절합니다.) 그래서 자신 만의 복사본 생성자를 정의한다면 원하는대로 모든 멤버 복사 생성자를 호출 할 수 있습니다. 여기

는 주변에 작은 당신이 어딘가에 복사하여 붙여 넣을 수있는 프로그램 엉망 :

#include <iostream> 

class Foo { 
public: 
    Foo() { 
     std::cout << "In Foo::Foo()" << std::endl; 
    } 

    Foo(const Foo& rhs) { 
     std::cout << "In Foo::Foo(const Foo&)" << std::endl; 
    } 
}; 

class Bar { 
public: 
    Bar() { 
     std::cout << "In Bar::Bar()" << std::endl; 
    } 

    Bar(const Bar& rhs) { 
     std::cout << "In Bar::Bar(const Bar&)" << std::endl; 
    } 
}; 

class Baz { 
public: 
    Foo foo; 
    Bar bar; 

    Baz() { 
     std::cout << "In Baz::Baz()" << std::endl; 
    } 

    Baz(const Baz& rhs) { 
     std::cout << "In Baz::Baz(const Baz&)" << std::endl; 
    } 
}; 

int main() { 
    Baz baz1; 
    std::cout << "Copying..." << std::endl; 
    Baz baz2(baz1); 
} 

있는 그대로,이 인쇄 : 그것의 구성원을 기본-초기화 있다는

 
In Foo::Foo() 
In Bar::Bar() 
In Baz::Baz() 
Copying... 
In Foo::Foo() 
In Bar::Bar() 
In Baz::Baz(const Baz&) 

주 Baz.

처럼 명시 적으로 복사 생성자을 주석으로 :

/* 
Baz(const Baz& rhs) { 
    std::cout << "In Baz::Baz(const Baz&)" << std::endl; 
} 
*/ 

출력이 될 것이다 :

 
In Foo::Foo() 
In Bar::Bar() 
In Baz::Baz() 
Copying... 
In Foo::Foo(const Foo&) 
In Bar::Bar(const Bar&) 

그것은 모두에서 복사 생성자를 호출합니다. 우리가 Baz 년대를 재 도입하는 경우

그리고 생성자를 복사 명시 적으로 단일 구성원 복사 :

Baz(const Baz& rhs) : 
    foo(rhs.foo) 
{ 
    std::cout << "In Baz::Baz(const Baz&)" << std::endl; 
} 

을 우리는 얻을 :

 
In Foo::Foo() 
In Bar::Bar() 
In Baz::Baz() 
Copying... 
In Foo::Foo(const Foo&) 
In Bar::Bar() 
In Baz::Baz(const Baz&) 

명시 적으로 복사 생성자를 선언하면 당신이 볼 수 있듯이 은 모든 반원을 복사 할 책임이 있습니다. 지금 당신의 생성자입니다.

이것은 이동 생성자를 포함한 모든 생성자에 적용됩니다.

Answer 2

예. Ctors는 ctors입니다.

Answer 3

초기화 생성자에 다른 멤버 생성자 호출을 명시 적으로 추가하지 않은 경우 기본 생성자가 호출되는 기본 생성자가있는 멤버 변수의 경우.

Answer 4

컴파일러가 기본 cctor를 제공하면 컴파일러가 멤버 변수에 대해 어떻게 생각합니까? 그것 복사본 구조 그것.

같은 맥락에서 cctor가 사용자 정의이고 일부 구성원을 제외하면 이러한 구성원을 초기화하지 않은 상태로 둘 수 없습니다. 계급 불변량은 건설 중에 설정되며 지속적으로 유지되어야합니다. 그래서, 컴파일러는 당신을 위해 그렇게합니다.

Answer 5

컴파일러가 필요할 경우 추가하는 것 외에는 복사 생성자에 관해 마술 같은 것이 없습니다. 그러나 실제로 실행되는 방법에는 특별한 것이 없습니다. "그러한 생성자 및 그러한 생성자 사용"을 명시 적으로 말하지 않으면 기본값을 사용합니다.

Answer 6

VC9에는 없습니다. 다른 사람들에 대해서는 확실하지 않습니다. 자세한 내용은

// compiled as: cl /EHsc contest.cpp 
// 
// Output was: 
// Child1() 
// ----- 
// Child1() 
// Child2() 
// Parent() 
// ----- 
// Child1(Child1&) 
// Child2() 
// Parent(Parent&) 

#include <cstdio> 

class Child1 { 
    int x; 
public: 
    static Child1 DEFAULT; 

    Child1(){ 
     x = 0; 
     printf("Child1()\n"); 
    } 

    Child1(Child1 &other){ 
     x = other.x; 
     printf("Child1(Child1&)\n"); 
    } 
}; 

Child1 Child1::DEFAULT; 

class Child2 { 
    int x; 
public: 
    Child2(){ 
     x = 0; 
     printf("Child2()\n"); 
    } 

    Child2(Child2 &other){ 
     x = other.x; 
     printf("Child2(Child2&)\n"); 
    } 
}; 

class Parent { 
    int x; 
    Child1 c1; 
    Child2 c2; 

public: 
    Parent(){ 
     printf("Parent()\n"); 
    } 

    Parent(Parent &other) : c1(Child1::DEFAULT) { 
     printf("Parent(Parent&)\n"); 
    } 
}; 

int main(){ 
    printf("-----\n"); 
    Parent p1; 
    printf("-----\n"); 
    Parent p2(p1); 

    return 0; 
} 

Answer 7

은 다음을 참조하십시오 Is there an implicit default constructor in C++?

짧은 : "기본 생성자"생성

• 컴파일러 : 각 멤버의 기본 생성자를 사용합니다.
• 컴파일러 생성 된 "복사본 생성자": 각 멤버의 복사본 생성자를 사용합니다.
• 생성 된 컴파일러 "할당 연산자": 각 멤버의 할당 연산자를 사용합니다.

Answer 8

기본 호출 생성자가 시작되는 방법에 따라 멤버 생성자도 같은 방식으로 호출됩니다. 예를 들어, 시작하자 :

struct ABC{ 
    int a; 
    ABC() : a(0) { printf("Default Constructor Called %d\n", a); }; 

    ABC(ABC & other) 
    { 
     a=other.a; 
     printf("Copy constructor Called %d \n" , a) ; 
    }; 
}; 

struct ABCDaddy{ 
    ABC abcchild; 
}; 

당신은이 테스트를 수행 할 수 있습니다

이

printf("\n\nTest two, where ABC is a member of another structure\n"); 
ABCDaddy aD; 
aD.abcchild.a=2; 

printf("\n Test: ABCDaddy bD=aD; \n"); 
ABCDaddy bD=aD; // Does call the copy constructor of the members of the structure ABCDaddy (ie. the copy constructor of ABC is called) 

printf("\n Test: ABCDaddy cD(aD); \n"); 
ABCDaddy cD(aD); // Does call the copy constructor of the members of the structure ABCDaddy (ie. the copy constructor of ABC is called) 

printf("\n Test: ABCDaddy eD; eD=aD; \n"); 
ABCDaddy eD; 
eD=aD;   // Does NOT call the copy constructor of the members of the structure ABCDaddy (ie. the copy constructor of ABC is not called) 

출력 :

Default Constructor Called 0 

Test: ABCDaddy bD=aD; 
Copy constructor Called 2 

Test: ABCDaddy cD(aD); 
Copy constructor Called 2 

Test: ABCDaddy eD; eD=aD; 
Default Constructor Called 0 

을 즐길 수 있습니다.