클래스의 인스턴스 만들기

클래스의 인스턴스 만들기

---

1, 2, 3, 4 행의 차이점은 무엇입니까?

언제 각각을 사용합니까?

3 행이 인쇄하고 constructor Foo7 행이 오류를 반환하고 8 행은 그렇지 않은 이유는 무엇입니까?

#include <iostream>     
using namespace std;

class Foo
 {
   public:
   Foo ( )
   {
      cout << "constructor Foo\n";
   }               
};

class Bar
 {
   public:
   Bar ( Foo )
   {
      cout << "constructor Bar\n";
   }
};

int main()
{
   /* 1 */ Foo* foo1 = new Foo ();
   /* 2 */ Foo* foo2 = new Foo;
   /* 3 */ Foo foo3;
   /* 4 */ Foo foo4 = Foo::Foo();

   /* 5 */ Bar* bar1 = new Bar ( *new Foo() );
   /* 6 */ Bar* bar2 = new Bar ( *new Foo );
   /* 7 */ Bar* bar3 = new Bar ( Foo foo5 );
   /* 8 */ Bar* bar3 = new Bar ( Foo::Foo() );

   return 1;
}

---

   /* 1 */ Foo* foo1 = new Foo ();

Foo동적 메모리 에 유형의 개체를 만듭니다 . foo1그것을 가리 킵니다. 일반적으로 C ++에서 원시 포인터를 사용하지 않고 스마트 포인터를 사용합니다. 경우 Foo포드 형이었다,이 (가 여기에 해당되지 않음) 값 초기화를 수행 할 것입니다.

   /* 2 */ Foo* foo2 = new Foo;

FooPOD 유형이 아니므 로 이전과 동일 합니다.

   /* 3 */ Foo foo3;

자동 저장소에서 Foo호출 되는 개체를 만듭니다 foo3.

   /* 4 */ Foo foo4 = Foo::Foo();

복사 초기화를 사용하여 자동 저장소에서 Foo호출 되는 개체 를 만듭니다 foo4.

   /* 5 */ Bar* bar1 = new Bar ( *new Foo() );

Uses Bar's conversion constructor to create an object of type Bar in dynamic storage. bar1 is a pointer to it.

   /* 6 */ Bar* bar2 = new Bar ( *new Foo );

Same as before.

   /* 7 */ Bar* bar3 = new Bar ( Foo foo5 );

This is just invalid syntax. You can't declare a variable there.

   /* 8 */ Bar* bar3 = new Bar ( Foo::Foo() );

Would work and work by the same principle to 5 and 6 if bar3 wasn't declared on in 7.

5 & 6 contain memory leaks.

Syntax like new Bar ( Foo::Foo() ); is not usual. It's usually new Bar ( (Foo()) ); - extra parenthesis account for most-vexing parse. (corrected)

---

1. Allocates some dynamic memory from the free store, and creates an object in that memory using its default constructor. You never delete it, so the memory is leaked.
2. Does exactly the same as 1; in the case of user-defined types, the parentheses are optional.
3. Allocates some automatic memory, and creates an object in that memory using its default constructor. The memory is released automatically when the object goes out of scope.
4. Similar to 3. Notionally, the named object foo4 is initialised by default-constructing, copying and destroying a temporary object; usually, this is elided giving the same result as 3.
5. Allocates a dynamic object, then initialises a second by copying the first. Both objects are leaked; and there's no way to delete the first since you don't keep a pointer to it.
6. Does exactly the same as 5.
7. Does not compile. Foo foo5 is a declaration, not an expression; function (and constructor) arguments must be expressions.
8. Creates a temporary object, and initialises a dynamic object by copying it. Only the dynamic object is leaked; the temporary is destroyed automatically at the end of the full expression. Note that you can create the temporary with just Foo() rather than the equivalent Foo::Foo() (or indeed Foo::Foo::Foo::Foo::Foo())

When do I use each?

1. Don't, unless you like unnecessary decorations on your code.
2. When you want to create an object that outlives the current scope. Remember to delete it when you've finished with it, and learn how to use smart pointers to control the lifetime more conveniently.
3. When you want an object that only exists in the current scope.
4. Don't, unless you think 3 looks boring and what to add some unnecessary decoration.
5. Don't, because it leaks memory with no chance of recovery.
6. Don't, because it leaks memory with no chance of recovery.
7. Don't, because it won't compile
8. When you want to create a dynamic Bar from a temporary Foo.

---

Lines 1,2,3,4 will call the default constructor. They are different in the essence as 1,2 are dynamically created object and 3,4 are statically created objects.

In Line 7, you create an object inside the argument call. So its an error.

And Lines 5 and 6 are invitation for memory leak.

참고URL : https://stackoverflow.com/questions/12248703/creating-an-instance-of-class