생성자/소멸자

 

Member function	typical form for class C:
생성자	C::C();
소멸자	C::~C();
복사 생성자	C::C (const C&);
대입 연산자	C& operator= (const C&);
이동 생성자	C::C (C&&);
이동 대입 연산자	C& operator= (C&&);

기본 생성자

기본 생성자 는 클래스의 개체가 선언되었지만 인수로 초기화되지 않을 때 호출되는 생성자입니다 .

클래스 정의에 생성자가 없으면 컴파일러는 클래스에 암시적으로 정의된 기본 생성자 가 있다고 가정합니다 . 따라서 다음과 같이 클래스를 선언한 후:

class Example {
  public:
    int total;
    void accumulate (int x) { total += x; }
};

컴파일러는 기본 생성자Example 가 있다고 가정합니다 . 따라서 이 클래스의 객체는 인수 없이 간단히 선언하여 생성할 수 있습니다.

Example ex;

그러나 클래스에 명시적으로 선언된 매개변수 수를 사용하는 일부 생성자가 있으면 컴파일러는 더 이상 암시적 기본 생성자를 제공하지 않으며 더 이상 인수 없이 해당 클래스의 새 객체 선언을 허용하지 않습니다. 예를 들어 다음 클래스:

class Example2 {
  public:
    int total;
    Example2 (int initial_value) : total(initial_value) { };
    void accumulate (int x) { total += x; };
};

여기에서 type 매개변수를 사용하여 생성자를 선언했습니다 int. 따라서 다음 개체 선언이 정확합니다.

Example2 ex (100);   // ok: calls constructor

그러나 다음:

Example2 ex;         // not valid: no default constructor

클래스가 하나의 인수를 취하는 명시적 생성자로 선언되었고 아무 것도 취하지 않는 암시적 기본 생성자 를 대체하기 때문에 유효하지 않습니다.

따라서 이 클래스의 객체가 인수 없이 생성되어야 하는 경우 적절한 기본 생성자 도 클래스에서 선언되어야 합니다. 예를 들어:

// classes and default constructors
#include <iostream>
#include <string>
using namespace std;

class Example3 {
    string data;
  public:
    Example3 (const string& str) : data(str) {}
    Example3() {}
    const string& content() const {return data;}
};

int main () {
  Example3 foo;
  Example3 bar ("Example");

  cout << "bar's content: " << bar.content() << '\n';
  return 0;
}

여기 Example3에는 빈 블록으로 정의된 기본 생성자 (즉, 매개변수가 없는 생성자)가 있습니다.

Example3() {}

이것은 클래스의 객체가 Example3인수 없이 생성되도록 허용합니다( foo이 예제에서 선언된 것처럼). 일반적으로 이와 같은 기본 생성자는 다른 생성자가 없는 모든 클래스에 대해 암시적으로 정의되므로 명시적 정의가 필요하지 않습니다. 그러나 이 경우 Example3에는 다른 생성자가 있습니다.

Example3 (const string& str);

생성자가 클래스에서 명시적으로 선언되면 암시적 기본 생성자 가 자동으로 제공되지 않습니다.

소멸자

소멸자는 생성자 의 반대 기능을 수행합니다. 소멸자 는 클래스의 수명이 종료될 때 클래스에 필요한 정리를 담당합니다. 이전 장에서 정의한 클래스는 리소스를 할당하지 않았으므로 실제로 정리가 필요하지 않았습니다.

그러나 이제 마지막 예제의 클래스가 데이터 멤버로 가지고 있던 문자열을 저장하기 위해 동적 메모리를 할당한다고 가정해 보겠습니다. 이 경우 이 메모리를 해제하는 역할을 하는 객체의 수명이 끝나면 자동으로 호출되는 함수를 갖는 것이 매우 유용할 것입니다. 이를 위해 소멸자 를 사용합니다 . 소멸자는 기본 생성자 와 매우 유사한 멤버 함수입니다 . 인수를 사용하지 않고 아무 것도 반환하지 않습니다.void. 또한 클래스 이름을 자체 이름으로 사용하지만 앞에 물결표 기호( ~)가 붙습니다.

// destructors
#include <iostream>
#include <string>
using namespace std;

class Example4 {
    string* ptr;
  public:
    // constructors:
    Example4() : ptr(new string) {}
    Example4 (const string& str) : ptr(new string(str)) {}
    // destructor:
    ~Example4 () {delete ptr;}
    // access content:
    const string& content() const {return *ptr;}
};

int main () {
  Example4 foo;
  Example4 bar ("Example");

  cout << "bar's content: " << bar.content() << '\n';
  return 0;
}

구성 시 Example4에 대한 스토리지를 할당합니다 string. 소멸자가 나중에 해제하는 저장소입니다.

객체의 소멸자는 수명이 끝나면 호출됩니다. 의 경우 함수의 끝에서 발생 foo합니다 .barmain

 

복사 생성자

개체가 자체 유형의 명명된 개체를 인수로 전달되면 복사본을 생성하기 위해 복사 생성자 가 호출됩니다. 복사 생성자 는 첫 번째 매개변수가 클래스 자체에 대한 유형 참조( 정규화될 수 있음)이고 이 유형의 단일 인수로 호출될 수

있는 생성자입니다. 예를 들어, 클래스 의 경우 복사 생성자 는 다음 서명을 가질 수 있습니다.constMyClass

MyClass::MyClass (const MyClass&);

클래스에 정의된 사용자 정의 복사 나 이동 생성자(또는 할당)가 없으면 암시적 복사 생성자 가 제공됩니다. 이 복사 생성자는 단순히 자체 멤버의 복사를 수행합니다. 예를 들어 다음과 같은 클래스의 경우:

class MyClass {
  public:
    int a, b; string c;
};

암시적 복사 생성자 는 자동으로 정의됩니다. 이 함수에 대해 가정된 정의는 다음 과 대략적으로 동일한 얕은 복사 를 수행합니다.

MyClass::MyClass(const MyClass& x) : a(x.a), b(x.b), c(x.c) {}

이 기본 복사 생성자 는 많은 클래스의 요구 사항에 적합할 수 있습니다. 그러나 얕은 복사Example4 는 클래스 자체의 멤버만 복사하며 , 이는 저장을 처리하는 포인터가 포함되어 있기 때문에 위에서 정의한 클래스와 같은 클래스에 대해 예상한 것과 다를 수 있습니다. 해당 클래스의 경우 얕은 복사 를 수행 한다는 것은 포인터 값이 복사되지만 내용 자체는 복사되지 않는다는 것을 의미합니다. 이것은 두 객체(복사본과 원본)가 단일 string객체를 공유하고(둘 다 동일한 객체를 가리키고 있음) 어떤 시점(파괴 시)에서 두 객체가 동일한 메모리 블록을 삭제하려고 시도한다는 것을 의미합니다. 아마도 런타임에 프로그램이 충돌하는 원인이 될 것입니다. 이것은 다음 사용자 정의를 정의하여 해결할 수 있습니다.깊은 복사 를 수행하는 복사 생성자 :

// copy constructor: deep copy
#include <iostream>
#include <string>
using namespace std;

class Example5 {
    string* ptr;
  public:
    Example5 (const string& str) : ptr(new string(str)) {}
    ~Example5 () {delete ptr;}
    // copy constructor:
    Example5 (const Example5& x) : ptr(new string(x.content())) {}
    // access content:
    const string& content() const {return *ptr;}
};

int main () {
  Example5 foo ("Example");
  Example5 bar = foo;

  cout << "bar's content: " << bar.content() << '\n';
  return 0;
}

이 복사 생성자 가 수행 하는 전체 복사는 원래 개체의 복사본을 포함하도록 초기화된 새 문자열에 대한 저장소를 할당합니다. 이러한 방식으로 두 개체(복사본 및 원본)에는 서로 다른 위치에 저장된 콘텐츠의 고유한 복사본이 있습니다.

복사 생성자

객체는 초기화될 때 구성 시 복사될 뿐만 아니라 모든 할당 작업에서도 복사할 수 있습니다. 차이점 보기:

MyClass foo;
MyClass bar (foo);       // object initialization: copy constructor called
MyClass baz = foo;       // object initialization: copy constructor called
foo = bar; 

구성 시 등호 를 baz사용하여 초기화 되지만 할당 작업이 아닙니다! (비록 하나처럼 보일 수 있음): 개체 선언은 할당 작업이 아니라 단일 인수 생성자를 호출하는 구문 중 하나일 뿐입니다. 할당 은 할당 작업입니다. 여기에 선언된 개체가 없지만 기존 개체에 대해 작업이 수행되고 있습니다. . 복사 할당 연산자 는 클래스 자체의 값이나 참조를 매개변수로 사용 하는 오버 로드 입니다 . 반환 값은 일반적으로 에 대한 참조 입니다(필수는 아니지만). 예를 들어 클래스 의 경우

foofoo

operator=*thisMyClass사본 할당 에는 다음 서명이 있을 수 있습니다.

MyClass& operator= (const MyClass&);

복사 할당 연산자 도 특수 함수 이며 클래스에 사용자 정의 복사 나 이동 할당(또는 이동 생성자)이 정의되지 않은 경우 암시적으로 정의됩니다 .

그러나 암시적 버전은 많은 클래스에 적합한 얕은 복사Example5 를 수행하지만 에서와 같이 저장소를 처리하는 객체에 대한 포인터가 있는 클래스에는 적합하지 않습니다 . 이 경우 해당 클래스가 가리키는 객체를 두 번 삭제할 위험이 있을 뿐만 아니라 할당 이전에 객체가 가리키는 객체를 삭제하지 않아 할당 시 메모리 누수가 발생한다. 이러한 문제는 복사 할당 으로 해결할 수 있습니다.이전 객체를 삭제하고 전체 복사 를 수행합니다 .

Example5& operator= (const Example5& x) {
  delete ptr;                      // delete currently pointed string
  ptr = new string (x.content());  // allocate space for new string, and copy
  return *this;
}

또는 멤버가 일정하지 않기 때문에 동일한 객체 string를 다시 사용할 수 있습니다 .string

Example5& operator= (const Example5& x) {
  *ptr = x.content();
  return *this;
}

대입 연산자

복사와 마찬가지로 이동도 개체의 값을 사용하여 다른 개체에 값을 설정합니다. 그러나 복사와 달리 콘텐츠는 실제로 한 개체(소스)에서 다른 개체(대상)로 전송됩니다. 소스는 해당 콘텐츠를 잃어버리고 대상이 인계합니다. 이 이동은 값의 소스가 이름 없는 개체 인 경우에만 발생 합니다 .

이름 없는 개체 는 본질적으로 일시적인 개체이므로 이름도 지정되지 않았습니다. 명명되지 않은 개체 의 일반적인 예는 함수 또는 유형 변환의 반환 값입니다.

다른 객체를 초기화하거나 값을 할당하기 위해 이와 같은 임시 객체의 값을 사용하는 것은 실제로 사본이 필요하지 않습니다. 객체는 다른 용도로 사용되지 않으므로 해당 값을 대상 으로 이동할 수 있습니다. 물체. 이러한 경우는 이동 생성자 와 이동 할당 을 트리거합니다 . 이동 생성자

는 명명되지 않은 임시를 사용하여 생성 시 개체가 초기화될 때 호출됩니다. 마찬가지로 이동 할당 은 개체에 이름 없는 임시 값이 할당될 때 호출됩니다.\

MyClass fn();            // function returning a MyClass object
MyClass foo;             // default constructor
MyClass bar = foo;       // copy constructor
MyClass baz = fn();      // move constructor
foo = bar;               // copy assignment
baz = MyClass();         // move assignment 

에 의해 반환된 fn값과 로 구성된 값 MyClass은 모두 이름이 지정되지 않은 임시 값입니다. 이러한 경우 이름 없는 개체는 수명이 매우 짧고 이것이 더 효율적인 작업일 때 다른 개체에 의해 획득될 수 있기 때문에 복사본을 만들 필요가 없습니다. 이동 생성자와 이동 할당은 클래스 자체 에 대한 rvalue 참조

유형의 매개변수를 사용하는 멤버입니다 .

MyClass (MyClass&&);             // move-constructor
MyClass& operator= (MyClass&&);  // move-assignment 

rvalue 참조 는 두 개의 앰퍼샌드( )가 있는 유형을 따라 지정 됩니다 &&. 매개변수로서 rvalue 참조 는 이 유형의 임시 인수와 일치합니다.

이동 개념은 new 및 delete로 저장소를 할당하는 개체와 같이 사용하는 저장소를 관리하는 개체에 가장 유용합니다. 이러한 개체에서 복사와 이동은 실제로 다른 작업입니다.
- A에서 B로 복사는 새 메모리가 B에 할당된 다음 A의 전체 내용이 B에 할당된 이 새 메모리에 복사 됨을 의미합니다.
- A에서 B로 이동하는 것은 A에 이미 할당된 메모리는 새로운 스토리지를 할당하지 않고 B로 전송됩니다. 그것은 단순히 포인터를 복사하는 것을 포함합니다.

예를 들어:

// move constructor/assignment
#include <iostream>
#include <string>
using namespace std;

class Example6 {
    string* ptr;
  public:
    Example6 (const string& str) : ptr(new string(str)) {}
    ~Example6 () {delete ptr;}
    // move constructor
    Example6 (Example6&& x) : ptr(x.ptr) {x.ptr=nullptr;}
    // move assignment
    Example6& operator= (Example6&& x) {
      delete ptr; 
      ptr = x.ptr;
      x.ptr=nullptr;
      return *this;
    }
    // access content:
    const string& content() const {return *ptr;}
    // addition:
    Example6 operator+(const Example6& rhs) {
      return Example6(content()+rhs.content());
    }
};


int main () {
  Example6 foo ("Exam");
  Example6 bar = Example6("ple");   // move-construction
  
  foo = foo + bar;                  // move-assignment

  cout << "foo's content: " << foo.content() << '\n';
  return 0;
}

컴파일러는 이미 반환 값 최적화 로 알려진 이동 구성 호출이 공식적으로 필요한 많은 경우를 최적화 합니다. 가장 주목할만한 것은 함수에서 반환된 값을 사용하여 개체를 초기화하는 것입니다. 이러한 경우 이동 생성자 는 실제로 호출되지 않을 수 있습니다. rvalue 참조

는 모든 함수 매개변수의 유형에 사용할 수 있지만 이동 생성자 이외의 용도에는 거의 유용하지 않습니다 . Rvalue 참조는 까다롭고 불필요한 사용은 추적하기 매우 어려운 오류의 원인이 될 수 있습니다.

암시적 구성원

위에서 설명한 6개의 특수 멤버 함수 는 특정 상황에서 클래스에 대해 암시적으로 선언된 멤버입니다.

 

멤버 함수	암시적으로 정의됨:	기본 정의:
기본 생성자	다른 생성자가 없는 경우	아무것도 하지 않는다
폐물 소각로	소멸자가 없다면	아무것도 하지 않는다
복사 생성자	이동 생성자와 이동 할당이 없는 경우	모든 구성원을 복사합니다.
과제 복사	이동 생성자와 이동 할당이 없는 경우	모든 구성원을 복사합니다.
이동 생성자	소멸자, 복사 생성자 및 복사 또는 이동 할당이 없는 경우	모든 구성원을 이동
과제 이동	소멸자, 복사 생성자 및 복사 또는 이동 할당이 없는 경우	모든 구성원을 이동

모든 특수 멤버 함수 가 동일한 경우에 암시적으로 정의되지 않는 방법에 유의하십시오. 이는 주로 C 구조 및 이전 C++ 버전과의 하위 호환성 때문이며 실제로 일부에는 사용되지 않는 경우가 포함되어 있습니다. 다행스럽게도 각 클래스는 이러한 멤버 중 기본 정의가 있는 멤버 또는 및 키워드를 사용하여 각각 삭제되는 멤버를 명시적으로 선택할 수 default있습니다 delete. 구문은 다음 중 하나입니다.

function_declaration = default;
function_declaration = delete;

// default and delete implicit members
#include <iostream>
using namespace std;

class Rectangle {
    int width, height;
  public:
    Rectangle (int x, int y) : width(x), height(y) {}
    Rectangle() = default;
    Rectangle (const Rectangle& other) = delete;
    int area() {return width*height;}
};

int main () {
  Rectangle foo;
  Rectangle bar (10,20);

  cout << "bar's area: " << bar.area() << '\n';
  return 0;
}

여기에서 Rectangle두 개의 int인수로 구성하거나 기본 구성 (인수 없음)으로 구성할 수 있습니다. 그러나 이 함수가 삭제되었기 때문에 다른 객체에서 복사 생성 할 수 없습니다 . Rectangle따라서 마지막 예의 개체를 가정하면 다음 명령문이 유효하지 않습니다.

Rectangle baz (foo);

그러나 복사 생성자를 다음과 같이 정의하여 명시적으로 유효하게 만들 수 있습니다.

Rectangle::Rectangle (const Rectangle& other) = default;

본질적으로 다음과 같습니다.

Rectangle::Rectangle (const Rectangle& other) : width(other.width), height(other.height) {}

키워드 는 기본 생성자default 와 동일한 멤버 함수를 정의하지 않지만 (즉, 기본 생성자 는 매개변수가 없는 생성자를 의미함) 삭제되지 않으면 암시적으로 정의되는 생성자와 동일합니다. 일반적으로 그리고 미래의 호환성을 위해 하나의 복사/이동 생성자 또는 하나의 복사/이동 할당을 명시적으로 정의하지만 둘 다 정의하지 않는 클래스는 명시적으로 정의 하지 않는 다른 특수 멤버 함수 중 하나 를 지정하는 것이 좋습니다.