스마트 포인터란 무엇이며 언제 사용해야 합니까?

Question

스마트 포인터란 무엇이며 언제 사용해야 합니까?

Answer 1

업데이트

이 답변은 다소 오래되었으므로 Boost 라이브러리에서 제공하는 스마트 포인터였던 당시 '좋은' 것이 무엇인지 설명합니다.C++11부터 표준 라이브러리는 충분한 스마트 포인터 유형을 제공하므로 다음을 사용하는 것이 좋습니다. std::unique_ptr, std::shared_ptr 그리고 std::weak_ptr.

도 있습니다 std::auto_ptr.복사할 수 있는 "특별한" 위험한 기능(예기치 않게 소유권을 양도하는 기능)도 있다는 점을 제외하면 범위가 지정된 포인터와 매우 유사합니다! 최신 표준에서는 더 이상 사용되지 않으므로 사용해서는 안 됩니다.사용 std::unique_ptr 대신에.

std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership. 
                                 // p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.

---

오래된 답변

스마트 포인터는 가리키는 개체의 수명을 관리하기 위해 '원시'(또는 '기본') C++ 포인터를 래핑하는 클래스입니다.단일 스마트 포인터 유형은 없지만 모두 실용적인 방식으로 원시 포인터를 추상화하려고 시도합니다.

원시 포인터보다 스마트 포인터를 선호해야 합니다.포인터를 사용해야 한다고 생각하는 경우(먼저 다음 사항을 고려하십시오. 정말 그렇지 않으면 일반적으로 스마트 포인터를 사용하는 것이 원시 포인터의 많은 문제(주로 객체 삭제를 잊어버리거나 메모리 누수)를 완화할 수 있기 때문에 사용하기를 원할 것입니다.

원시 포인터를 사용하면 프로그래머는 개체가 더 이상 유용하지 않을 때 개체를 명시적으로 삭제해야 합니다.

// Need to create the object to achieve some goal
MyObject* ptr = new MyObject(); 
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?

이에 비해 스마트 포인터는 객체가 소멸되는 시점에 대한 정책을 정의합니다.여전히 객체를 생성해야 하지만 더 이상 객체 파괴에 대해 걱정할 필요가 없습니다.

SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.

// Destruction of the object happens, depending 
// on the policy the smart pointer class uses.

// Destruction would happen even if DoSomething() 
// raises an exception

사용 중인 가장 간단한 정책은 다음과 같이 구현되는 스마트 포인터 래퍼 개체의 범위와 관련됩니다. boost::scoped_ptr 또는 std::unique_ptr.

void f()
{
    {
       std::unique_ptr<MyObject> ptr(new MyObject());
       ptr->DoSomethingUseful();
    } // ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}

참고하세요 std::unique_ptr 인스턴스를 복사할 수 없습니다.이렇게 하면 포인터가 여러 번(잘못) 삭제되는 것을 방지할 수 있습니다.그러나 호출하는 다른 함수에 대한 참조를 전달할 수 있습니다.

std::unique_ptrs는 개체의 수명을 특정 코드 블록에 연결하거나 다른 개체 내부에 멤버 데이터로 포함시킨 경우 해당 다른 개체의 수명을 연결하려는 경우 유용합니다.객체는 포함하는 코드 블록이 종료되거나 포함하는 객체 자체가 소멸될 때까지 존재합니다.

보다 복잡한 스마트 포인터 정책에는 포인터 참조 계산이 포함됩니다.이렇게 하면 포인터를 복사할 수 있습니다.개체에 대한 마지막 "참조"가 삭제되면 개체가 삭제됩니다.이 정책은 다음에 의해 시행됩니다. boost::shared_ptr 그리고 std::shared_ptr.

void f()
{
    typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
    MyObjectPtr p1; // Empty

    {
        MyObjectPtr p2(new MyObject());
        // There is now one "reference" to the created object
        p1 = p2; // Copy the pointer.
        // There are now two references to the object.
    } // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero. 
  // The object is deleted.

참조 계산 포인터는 개체의 수명이 훨씬 더 복잡하고 코드의 특정 섹션이나 다른 개체에 직접 연결되지 않은 경우 매우 유용합니다.

카운트된 포인터를 참조하는 데에는 한 가지 단점이 있습니다. 즉, 매달린 참조를 생성할 수 있다는 것입니다.

// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!

또 다른 가능성은 순환 참조를 만드는 것입니다.

struct Owner {
   std::shared_ptr<Owner> other;
};

std::shared_ptr<Owner> p1 (new Owner());
std::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1

// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!

이 문제를 해결하기 위해 Boost와 C++11은 모두 다음을 정의했습니다. weak_ptr 약한(계산되지 않은) 참조를 정의하려면 shared_ptr.

Answer 2

요즘 최신 C++에 대한 간단한 대답은 다음과 같습니다.

• 스마트 포인터란 무엇입니까?
  값을 포인터처럼 사용할 수 있지만 자동 메모리 관리의 추가 기능을 제공하는 유형입니다.스마트 포인터가 더 이상 사용되지 않으면 가리키는 메모리가 할당 해제됩니다(참조: Wikipedia에 대한 더 자세한 정의).
• 언제 사용해야 합니까?
  메모리의 소유권을 추적하고 할당 또는 할당 해제를 포함하는 코드에서;스마트 포인터를 사용하면 이러한 작업을 명시적으로 수행할 필요가 없어집니다.
• 그렇다면 어떤 경우에 어떤 스마트 포인터를 사용해야 할까요?
  • 사용 std::unique_ptr 동일한 객체에 대한 여러 참조를 보유하지 않으려는 경우.예를 들어, 일부 범위에 들어갈 때 할당되고 범위를 나갈 때 할당 해제되는 메모리에 대한 포인터에 사용합니다.
  • 사용 std::shared_ptr 여러 위치에서 개체를 참조하고 싶고 이러한 참조가 모두 사라질 때까지 개체 할당이 취소되는 것을 원하지 않는 경우.
  • 사용 std::weak_ptr 여러 위치에서 개체를 참조하려는 경우 - 무시하고 할당을 취소해도 괜찮은 참조의 경우(따라서 역참조하려고 할 때 개체가 사라진 것을 알 수 있습니다).
  • 다음을 사용하지 마십시오. boost:: 스마트 포인터 또는 std::auto_ptr 필요한 경우 읽을 수 있는 특별한 경우를 제외하고.
• 안녕하세요, 어느 것을 사용해야 하는지는 묻지 않았습니다!
  아, 하지만 당신은 정말 인정하고 싶었어요.
• 그렇다면 언제 일반 포인터를 사용해야 할까요?
  대부분 메모리 소유권을 인식하지 못하는 코드에 있습니다.이는 일반적으로 다른 곳에서 포인터를 가져오고 할당하거나 할당 해제하지 않고 실행보다 오래 지속되는 포인터의 복사본을 저장하지 않는 함수에 있습니다.

Answer 3

스마트 포인터 몇 가지 추가 기능을 갖춘 포인터와 유사한 유형입니다.자동 메모리 할당 해제, 참조 카운팅 등

페이지에서 작은 소개를 볼 수 있습니다. 스마트 포인터 - 무엇을, 왜, 무엇을?.

간단한 스마트 포인터 유형 중 하나는 다음과 같습니다. std::auto_ptr (C++ 표준의 20.4.5장) 이는 범위를 벗어날 때 자동으로 메모리 할당을 해제할 수 있고 유연성은 떨어지지만 예외가 발생할 때 단순한 포인터 사용보다 더 강력합니다.

또 다른 편리한 유형은 boost::shared_ptr 참조 계산을 구현하고 객체에 대한 참조가 남아 있지 않으면 자동으로 메모리 할당을 취소합니다.이는 메모리 누수를 방지하는 데 도움이 되며 구현하는 데 사용하기 쉽습니다. 라이.

주제는 책에서 깊이 다루고 있습니다. "C++ 템플릿:완벽한 가이드' 작성자: David Vandevoorde, Nicolai M.요수티스, 20장.스마트 포인터.다루는 일부 주제:

• 예외로부터 보호
• 홀더(참고, 표준::auto_ptr 이러한 유형의 스마트 포인터 구현입니다)
• 자원 획득은 초기화입니다 (이것은 C++에서 예외로부터 안전한 리소스 관리에 자주 사용됩니다.)
• 홀더 제한
• 참조 계산
• 동시 카운터 액세스
• 파괴 및 할당 해제

Answer 4

Chris, Sergdev 및 Llyod가 제공한 정의가 정확합니다.하지만 나는 내 삶을 단순하게 유지하기 위해 더 간단한 정의를 선호합니다.스마트 포인터는 단순히 -> 그리고 * 연산자.이는 개체가 의미상 포인터처럼 보이지만 참조 계산, 자동 소멸 등을 포함하여 훨씬 더 멋진 작업을 수행하도록 만들 수 있음을 의미합니다.shared_ptr 그리고 auto_ptr 대부분의 경우 충분하지만 고유한 작은 특이점이 있습니다.

Answer 5

스마트 포인터는 포인터 자체가 범위를 벗어나면 포인터가 가리키는 것도 삭제된다는 점을 제외하면 "char*"와 같은 일반(입력된) 포인터와 같습니다."->"를 사용하여 일반 포인터처럼 사용할 수 있지만 데이터에 대한 실제 포인터가 필요한 경우에는 사용할 수 없습니다.이를 위해 "&*ptr"을 사용할 수 있습니다.

다음과 같은 경우에 유용합니다.

• new로 할당해야 하지만 해당 스택에 있는 항목과 동일한 수명을 갖고 싶은 개체입니다.객체가 스마트 포인터에 할당되면 프로그램이 해당 기능/블록을 종료할 때 삭제됩니다.

• 클래스의 데이터 멤버. 객체가 삭제되면 소멸자에 특별한 코드 없이 소유한 모든 데이터도 삭제됩니다(소멸자가 가상인지 확인해야 하며 이는 거의 항상 좋은 일입니다). .

당신은 할 수있다 ~ 아니다 다음과 같은 경우에 스마트 포인터를 사용하고 싶습니다.

• ...포인터는 실제로 데이터를 소유해서는 안됩니다 ...즉, 데이터를 사용하고 있지만 참조하는 기능에서 데이터가 계속 유지되기를 원하는 경우입니다.
• ...스마트 포인터 자체는 어느 시점에서 파괴되지 않습니다.결코 파괴되지 않는 메모리(예: 동적으로 할당되지만 명시적으로 삭제되지 않는 객체)에 위치하는 것을 원하지 않습니다.
• ...두 개의 스마트 포인터가 동일한 데이터를 가리킬 수 있습니다.(그러나 이를 처리할 수 있는 더 똑똑한 포인터가 있습니다...그것은 호출됩니다 참조 카운팅.)

또한보십시오:

• 쓰레기 수거.
• 이 스택 오버플로 질문 데이터 소유권에 관해

Answer 6

대부분의 종류의 스마트 포인터는 개체에 대한 포인터 삭제를 처리합니다.더 이상 수동으로 개체를 처리할 필요가 없기 때문에 매우 편리합니다.

가장 일반적으로 사용되는 스마트 포인터는 다음과 같습니다. std::tr1::shared_ptr (또는 boost::shared_ptr), 그리고 덜 일반적으로, std::auto_ptr.정기적으로 사용하는 것을 권장합니다 shared_ptr.

shared_ptr 매우 다재다능하며 객체가 "DLL 경계를 넘어 전달"되어야 하는 경우(다른 경우 일반적인 악몽 사례)를 포함하여 매우 다양한 폐기 시나리오를 처리합니다. libcs는 코드와 DLL 사이에 사용됩니다).

Answer 7

스마트 포인터는 포인터처럼 작동하지만 추가로 구성, 파괴, 복사, 이동 및 역참조에 대한 제어 기능을 제공하는 개체입니다.

자신만의 스마트 포인터를 구현할 수 있지만 많은 라이브러리에서는 각각 서로 다른 장점과 단점이 있는 스마트 포인터 구현을 제공합니다.

예를 들어, 후원 다음과 같은 스마트 포인터 구현을 제공합니다.

• shared_ptr<T> 에 대한 포인터입니다 T 객체가 더 이상 필요하지 않은 시기를 결정하기 위해 참조 카운트를 사용합니다.
• scoped_ptr<T> 범위를 벗어나면 자동으로 삭제되는 포인터입니다.할당이 불가능합니다.
• intrusive_ptr<T> 또 다른 참조 카운팅 포인터입니다.것보다 더 나은 성능을 제공합니다. shared_ptr, 하지만 다음 유형이 필요합니다. T 자체 참조 계산 메커니즘을 제공합니다.
• weak_ptr<T> 약한 포인터이며 함께 작동합니다. shared_ptr 순환 참조를 피하기 위해.
• shared_array<T> 처럼 shared_ptr, 그러나 배열의 경우 T.
• scoped_array<T> 처럼 scoped_ptr, 그러나 배열의 경우 T.

이는 각각에 대한 하나의 선형 설명일 뿐이며 필요에 따라 사용할 수 있습니다. 자세한 내용과 예를 보려면 Boost 문서를 참조하세요.

또한 C++ 표준 라이브러리는 세 가지 스마트 포인터를 제공합니다. std::unique_ptr 고유한 소유권을 위해, std::shared_ptr 공유 소유권과 std::weak_ptr. std::auto_ptr C++03에 존재했지만 이제는 더 이상 사용되지 않습니다.

Answer 8

비슷한 답변에 대한 링크는 다음과 같습니다. http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html

스마트 포인터는 일반 포인터처럼 작동하고, 보이고, 느껴지지만 더 많은 기능을 제공하는 개체입니다.C++에서 스마트 포인터는 포인터를 캡슐화하고 표준 포인터 연산자를 재정의하는 템플릿 클래스로 구현됩니다.일반 포인터에 비해 여러 가지 장점이 있습니다.null 포인터나 힙 개체에 대한 포인터로 초기화되는 것이 보장됩니다.널 포인터를 통한 간접 참조가 확인됩니다.삭제가 필요하지 않습니다.객체에 대한 마지막 포인터가 사라지면 객체는 자동으로 해제됩니다.이러한 스마트 포인터의 한 가지 중요한 문제는 일반 포인터와 달리 상속을 존중하지 않는다는 것입니다.스마트 포인터는 다형성 코드에 적합하지 않습니다.아래는 스마트 포인터 구현에 대한 예입니다.

예:

template <class X>
class smart_pointer
{
          public:
               smart_pointer();                          // makes a null pointer
               smart_pointer(const X& x)            // makes pointer to copy of x

               X& operator *( );
               const X& operator*( ) const;
               X* operator->() const;

               smart_pointer(const smart_pointer <X> &);
               const smart_pointer <X> & operator =(const smart_pointer<X>&);
               ~smart_pointer();
          private:
               //...
};

이 클래스는 X 유형의 객체에 대한 스마트 포인터를 구현합니다.객체 자체는 힙에 위치합니다.사용 방법은 다음과 같습니다.

smart_pointer <employee> p= employee("Harris",1333);

다른 오버로드된 연산자와 마찬가지로 p도 일반 포인터처럼 동작합니다.

cout<<*p;
p->raise_salary(0.5);

Answer 9

http://en.wikipedia.org/wiki/Smart_pointer

컴퓨터 과학에서 스마트 포인터는 자동 쓰레기 수집 또는 바운드 점검과 같은 추가 기능을 제공하면서 포인터를 시뮬레이션하는 추상 데이터 유형입니다.이러한 추가 기능은 효율성을 유지하면서 포인터의 오용으로 인한 버그를 줄이기위한 것입니다.스마트 포인터는 일반적으로 메모리 관리의 목적으로 그들을 가리키는 객체를 추적합니다.포인터의 오용은 버그의 주요 원인입니다.포인터를 사용하여 작성된 프로그램에 의해 수행되어야하는 지속적인 할당, 거래 및 참조는 일부 메모리 누출이 발생할 가능성이 높습니다.스마트 포인터는 리소스 거래를 자동으로 만들어 메모리 누출을 방지하려고합니다.물체에 대한 포인터 (또는 일련의 포인터에서 마지막)에 대한 포인터가 파괴 될 때, 예를 들어 범위를 벗어나기 때문에 뾰족한 물체도 파괴됩니다.

Answer 10

C ++ 의이 튜토리얼 포인터의 클래스가 3 가지 유형으로 나눌 수 있습니다.

1) 원시 포인터 :

T a;  
T * _ptr = &a; 

그들은 메모리의 한 위치에 대한 메모리 주소를 보유합니다.프로그램이 복잡해져서 추적하기 어려워지므로 주의해서 사용하십시오.

const 데이터 또는 주소가 있는 포인터 { 뒤로 읽기 }

T a ; 
const T * ptr1 = &a ; 
T const * ptr1 = &a ;

const인 데이터 유형 T에 대한 포인터입니다.즉, 포인터를 사용하여 데이터 유형을 변경할 수 없습니다.즉 *ptr1 = 19 ;작동 안 할 것이다.하지만 포인터를 이동할 수는 있습니다.즉 ptr1++ , ptr1-- ;등이 작동합니다.거꾸로 읽기 :const인 T 유형에 대한 포인터

  T * const ptr2 ;

데이터 유형 T 에 대한 const 포인터입니다.즉, 포인터를 이동할 수는 없지만 포인터가 가리키는 값은 변경할 수 있습니다.즉 *ptr2 = 19 작동하지만 ptr2++ ; ptr2-- 등은 작동하지 않습니다.거꾸로 읽기 :T 유형에 대한 const 포인터

const T * const ptr3 ; 

const 데이터 유형 T 에 대한 const 포인터입니다.즉, 포인터를 이동할 수 없으며 데이터 유형 포인터를 포인터로 변경할 수도 없습니다.즉 . ptr3-- ; ptr3++ ; *ptr3 = 19; 작동 안 할 것이다

3) 스마트 포인터 : { #include <memory> }

공유 포인터:

  T a ; 
     //shared_ptr<T> shptr(new T) ; not recommended but works 
     shared_ptr<T> shptr = make_shared<T>(); // faster + exception safe

     std::cout << shptr.use_count() ; // 1 //  gives the number of " 
things " pointing to it. 
     T * temp = shptr.get(); // gives a pointer to object

     // shared_pointer used like a regular pointer to call member functions
      shptr->memFn();
     (*shptr).memFn(); 

    //
     shptr.reset() ; // frees the object pointed to be the ptr 
     shptr = nullptr ; // frees the object 
     shptr = make_shared<T>() ; // frees the original object and points to new object

포인터가 가리키는 개체를 가리키는 "사물"의 수를 추적하기 위해 참조 계산을 사용하여 구현되었습니다.이 개수가 0이 되면 개체가 자동으로 삭제됩니다. 즉, 개체를 가리키는 모든 share_ptr이 범위를 벗어나면 objected가 삭제됩니다.이는 new를 사용하여 할당한 객체를 삭제해야 하는 골치 아픈 일을 없애줍니다.

약한 포인터: 공유 포인터를 사용할 때 발생하는 주기적 참조를 다루는 데 도움이됩니다. 두 개의 공유 포인터가 가리키고 서로 공유 포인터를 가리키는 내부 공유 포인터가 있으면 주기적 기준이 있고 객체가 삭제되지 않으면 객체가 삭제되지 않습니다. 공유 포인터는 범위를 벗어납니다.이 문제를 해결하려면 내부 멤버를 shared_ptr에서 Weak_ptr로 변경하세요.메모 :약한 포인터가 가리키는 요소에 접근하려면 lock() 을 사용하세요. 그러면 Weak_ptr이 반환됩니다.

T a ; 
shared_ptr<T> shr = make_shared<T>() ; 
weak_ptr<T> wk = shr ; // initialize a weak_ptr from a shared_ptr 
wk.lock()->memFn() ; // use lock to get a shared_ptr 
//   ^^^ Can lead to exception if the shared ptr has gone out of scope
if(!wk.expired()) wk.lock()->memFn() ;
// Check if shared ptr has gone out of scope before access

보다 : std::weak_ptr은 언제 유용합니까?

고유 포인터: 독점적인 소유권을 가진 경량 스마트 포인터입니다.포인터 간에 개체를 공유하지 않고 포인터가 고유한 개체를 가리킬 때 사용합니다.

unique_ptr<T> uptr(new T);
uptr->memFn(); 

//T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptr
uptr.reset() ; // deletes the object pointed to by uptr 

고유한 ptr이 가리키는 객체를 변경하려면 이동 의미론을 사용하세요.

unique_ptr<T> uptr1(new T);
unique_ptr<T> uptr2(new T);
uptr2 = std::move(uptr1); 
// object pointed by uptr2 is deleted and 
// object pointed by uptr1 is pointed to by uptr2
// uptr1 becomes null 

참고자료 :이들은 본질적으로 const 포인터로 간주될 수 있습니다. 즉, const이고 더 나은 구문으로 이동할 수 없는 포인터입니다.

보다 : C++에서 포인터 변수와 참조 변수의 차이점은 무엇입니까?

r-value reference : reference to a temporary object   
l-value reference : reference to an object whose address can be obtained
const reference : reference to a data type which is const and cannot be modified 

참조 :https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ 이 질문을 지적해준 Andre에게 감사드립니다.

Answer 11

스마트 포인터는 일반 포인터의 래퍼인 클래스입니다.일반 포인터와 달리 스마트 포인트의 라이프 서클은 참조 횟수(스마트 포인터 개체가 할당된 횟수)를 기반으로 합니다.따라서 스마트 포인터가 다른 포인터에 할당될 때마다 내부 참조 카운트에 플러스가 더해집니다.그리고 객체가 범위를 벗어날 때마다 참조 횟수에서 마이너스가 발생합니다.

자동 포인터는 비슷해 보이지만 스마트 포인터와는 전혀 다릅니다.자동 포인터 객체가 변수 범위를 벗어날 때마다 리소스 할당을 해제하는 편리한 클래스입니다.어느 정도 동적으로 할당된 메모리에 대한 포인터가 스택 변수(컴파일 시간에 정적으로 할당됨)와 유사하게 작동합니다.

Answer 12

스마트 포인터는 메모리 할당 해제, 리소스 공유 및 전송에 대해 걱정할 필요가 없는 포인터입니다.

Java에서 할당이 작동하는 것과 유사한 방식으로 이러한 포인터를 사용할 수 있습니다.Java Garbage Collector에서는 트릭을 수행하지만 스마트 포인터에서는 소멸자가 트릭을 수행합니다.

Answer 13

기존 답변은 좋지만 스마트 포인터가 해결하려는 문제에 대한 (완전한) 답변이 아닐 때 수행할 작업을 다루지 않습니다.

무엇보다도 스마트 포인터를 사용하는 것이 (다른 답변에서 잘 설명됨) 가능한 해결책입니다. 추상 클래스를 함수 반환 유형으로 어떻게 사용합니까? 이 질문과 중복된 것으로 표시되었습니다.그러나 C++에서 추상(또는 실제로는 임의) 기본 클래스를 반환 유형으로 지정하려는 유혹을 받는 경우 첫 번째 질문은 "정말로 무엇을 의미합니까?"입니다.C++의 관용적 객체 지향 프로그래밍(그리고 이것이 다른 언어와 어떻게 다른지)에 대한 좋은 토론(추가 참조 포함)이 다음 문서에 있습니다. 부스트 포인터 컨테이너 라이브러리.요약하자면, C++에서는 소유권에 대해 생각해야 합니다.어떤 스마트 포인터가 도움이 되지만 유일한 솔루션은 아니거나 항상 완전한 솔루션이 아니며(다형성 복사본을 제공하지 않음) 항상 인터페이스에 노출하려는 솔루션이 아니며 함수 반환이 끔찍하게 들립니다. 인터페이스와 매우 흡사합니다).예를 들어 참조를 반환하는 것만으로도 충분할 수 있습니다.그러나 이러한 모든 경우(스마트 포인터, 포인터 컨테이너 또는 단순히 참조 반환)에서 반환을 다음에서 변경했습니다. 값 어떤 형태로든 참조.정말로 복사가 필요한 경우 더 많은 상용구 "관용어"를 추가하거나 C++의 관용적(또는 기타) OOP를 넘어 다음과 같은 라이브러리를 사용하여 보다 일반적인 다형성으로 이동해야 할 수도 있습니다. 어도비 폴리 또는 Boost.TypeErasure.