왜 객체 자체보다는 포인터를 사용해야합니까?

Java 배경에서 왔으며 C ++에서 객체 작업을 시작했습니다. 그러나 나에게 일어난 한 가지는 사람들이 종종 객체 자체가 아닌 객체에 대한 포인터를 사용한다는 것입니다.

Object *myObject = new Object;

오히려

Object myObject;

또는 함수를 사용하는 대신 testFunc()다음과 같이 말합니다 .

myObject.testFunc();

우리는 다음과 같이 작성해야합니다.

myObject->testFunc();

그러나 왜 우리가 이런 식으로 해야하는지 알 수 없습니다. 메모리 주소에 직접 액세스 할 수 있기 때문에 효율성과 속도와 관련이 있다고 가정합니다. 내가 맞아?

동적 할당이 너무 자주 나타나는 것은 매우 불행한 일입니다. 그것은 단지 얼마나 나쁜 C ++ 프로그래머가 있는지 보여줍니다.

어떤 의미에서, 당신은 두 개의 질문을 하나로 묶습니다. 첫 번째는 언제 동적 할당을 사용해야 new합니까? 두 번째는 언제 포인터를 사용해야합니까?

중요한 가정 메시지는 항상 해당 작업에 적합한 도구를 사용해야 한다는 것 입니다. 거의 모든 상황에서 수동 동적 할당을 수행하거나 원시 포인터를 사용하는 것보다 더 적절하고 안전한 것이 있습니다.

동적 할당

귀하의 질문에, 당신은 객체를 생성하는 두 가지 방법을 보여주었습니다. 주요 차이점은 객체의 저장 기간입니다. Object myObject;블록 내에서 작업 할 때 개체는 자동 저장 기간으로 생성되므로 범위를 벗어나면 자동으로 삭제됩니다. 그렇게 new Object()하면 객체의 동적 저장 기간이 유지되므로 명시 적으로 객체가 유지 될 때까지 활성 상태를 유지 delete합니다. 필요할 때만 동적 스토리지 기간을 사용해야합니다. 즉, 가능한 경우 자동 저장 시간으로 객체를 생성하는 것을 항상 선호 해야합니다 .

동적 할당이 필요할 수있는 주요 두 상황 :

1. 현재 범위보다 오래 지속되는 개체가 필요합니다 ( 복사본이 아닌 특정 메모리 위치에있는 특정 개체). 개체를 복사 / 이동해도 (대부분의 경우) 자동 개체를 선호해야합니다.
2. 스택을 쉽게 채울 수 있는 많은 메모리를 할당해야합니다 . 실제로 C ++의 범위를 벗어 났기 때문에이 문제에 대해 걱정할 필요가 없다면 좋을 것입니다. 그러나 불행히도 우리는 시스템의 현실을 다루어야합니다. 우리는 개발 중입니다.

동적 할당이 절대적으로 필요한 경우 스마트 포인터 또는 RAII 를 수행하는 다른 유형 (예 : 표준 컨테이너)으로 캡슐화해야합니다 . 스마트 포인터는 동적으로 할당 된 객체의 소유권 의미를 제공합니다. 한 번 봐 std::unique_ptr및 std::shared_ptr예를 들어,. 적절하게 사용하면 거의 모든 메모리 관리를 수행하지 않아도됩니다 ( 0 의 규칙 참조 ).

포인터

그러나 동적 할당 이외의 원시 포인터에는 다른 일반적인 용도가 있지만 대부분 선호하는 대안이 있습니다. 이전과 마찬가지로 포인터가 실제로 필요한 경우가 아니면 항상 대안을 선호하십시오 .

1. 참조 의미론이 필요합니다 . 때로는 전달 된 함수가 특정 객체 (복사본이 아닌)에 액세스 할 수 있기를 원하기 때문에 포인터가 할당 된 방법에 관계없이 객체를 전달하려고 할 때가 있습니다. 그러나 대부분의 경우 포인터에 대한 참조 유형을 선호해야합니다. 이는 포인터가 특별히 설계된 것이므로 포인터에 대한 것입니다. 위의 상황 1에서와 같이 반드시 개체의 수명을 현재 범위를 넘어 연장하는 것은 아닙니다. 이전과 같이 객체 사본을 전달해도 괜찮다면 참조 의미론이 필요하지 않습니다.

2. 다형성이 필요합니다 . 객체에 대한 포인터 나 참조를 통해서만 다형성으로 (즉, 객체의 동적 유형에 따라) 함수를 호출 할 수 있습니다. 이것이 필요한 동작이면 포인터 또는 참조를 사용해야합니다. 다시, 참조가 바람직하다.

3. nullptr객체를 생략 할 때 a 를 전달 하여 객체가 선택 사항임을 나타내 려고합니다. 인수 인 경우 기본 인수 또는 함수 오버로드를 사용하는 것이 좋습니다. 그렇지 않으면이 동작을 캡슐화하는 유형을 사용하는 것이 좋습니다 std::optional( 예 : C ++ 17에서 도입 됨-이전 C ++ 표준에서는 boost::optional).

4. 컴파일 시간을 향상시키기 위해 컴파일 단위를 분리하려고합니다 . 포인터의 유용한 속성은 뾰족한 유형의 전달 선언 만 필요하다는 것입니다 (실제로 객체를 사용하려면 정의가 필요합니다). 이를 통해 컴파일 프로세스의 일부를 분리하여 컴파일 시간을 크게 향상시킬 수 있습니다. Pimpl 관용구를 참조하십시오 .

5. C 라이브러리 또는 C 스타일 라이브러리 와 인터페이스해야합니다 . 이 시점에서 원시 포인터를 사용해야합니다. 가장 좋은 방법은 마지막 순간에 원시 포인터를 느슨하게 놓는 것입니다. 예를 들어 get멤버 함수 를 사용하여 스마트 포인터에서 원시 포인터를 얻을 수 있습니다 . 라이브러리가 핸들을 통해 할당 해제 할 것으로 예상되는 일부 할당을 수행하는 경우, 오브젝트를 적절하게 할당 해제하는 사용자 정의 삭제 도구를 사용하여 스마트 포인터로 핸들을 랩핑 할 수 있습니다.

포인터에 대한 많은 사용 사례가 있습니다.

다형성 행동 . 다형성 유형의 경우 슬라이싱을 피하기 위해 포인터 (또는 참조)가 사용됩니다.

class Base { ... };
class Derived : public Base { ... };

void fun(Base b) { ... }
void gun(Base* b) { ... }
void hun(Base& b) { ... }

Derived d;
fun(d);    // oops, all Derived parts silently "sliced" off
gun(&d);   // OK, a Derived object IS-A Base object
hun(d);    // also OK, reference also doesn't slice

참조 의미론 및 복사 방지 . 다형성이 아닌 유형의 경우 포인터 (또는 참조)는 값 비싼 객체를 복사하지 않도록합니다.

Base b;
fun(b);  // copies b, potentially expensive 
gun(&b); // takes a pointer to b, no copying
hun(b);  // regular syntax, behaves as a pointer

C ++ 11에는 값 비싼 객체의 많은 복사본을 함수 인수 및 반환 값으로 피할 수있는 의미 체계가 이동했습니다. 그러나 포인터를 사용하면 해당 객체를 피할 수 있으며 동일한 객체에 여러 개의 포인터를 사용할 수 있습니다 (객체는 한 번만 이동할 수 있음).

자원 확보 . new연산자를 사용하여 리소스에 대한 포인터를 만드는 것은 최신 C ++ 의 안티 패턴 입니다. 특수 자원 클래스 (표준 컨테이너 중 하나) 또는 스마트 포인터 ( std::unique_ptr<>또는 std::shared_ptr<>)를 사용하십시오. 치다:

{
    auto b = new Base;
    ...       // oops, if an exception is thrown, destructor not called!
    delete b;
}

vs.

{
    auto b = std::make_unique<Base>();
    ...       // OK, now exception safe
}

원시 포인터는 "보기"로만 사용해야하며 소유권에 관여하지 않아야합니다 (직접 생성 또는 반환 값을 통한 암시 적). C ++ FAQ의이 Q & A 도 참조하십시오 .

보다 세분화 된 수명 제어 공유 포인터를 복사 할 때마다 (예 : 함수 인수로) 가리키는 자원이 활성 상태로 유지됩니다. new범위를 벗어나면 일반 객체 ( 사용자가 직접 또는 리소스 클래스 내부에서 직접 생성하지 않음 )가 소멸됩니다.

앞으로의 선언, 다형성 등의 중요한 유스 케이스를 포함 하여이 질문에 대한 훌륭한 답변이 많이 있지만 질문의 "영혼"의 일부에는 대답이 없다고 느낍니다.

두 언어를 비교하는 상황을 살펴 보자.

자바:

Object object1 = new Object(); //A new object is allocated by Java
Object object2 = new Object(); //Another new object is allocated by Java

object1 = object2; 
//object1 now points to the object originally allocated for object2
//The object originally allocated for object1 is now "dead" - nothing points to it, so it
//will be reclaimed by the Garbage Collector.
//If either object1 or object2 is changed, the change will be reflected to the other

이에 가장 가까운 것은 다음과 같습니다.

C ++ :

Object * object1 = new Object(); //A new object is allocated on the heap
Object * object2 = new Object(); //Another new object is allocated on the heap
delete object1;
//Since C++ does not have a garbage collector, if we don't do that, the next line would 
//cause a "memory leak", i.e. a piece of claimed memory that the app cannot use 
//and that we have no way to reclaim...

object1 = object2; //Same as Java, object1 points to object2.

대안적인 C ++ 방식을 보자 :

Object object1; //A new object is allocated on the STACK
Object object2; //Another new object is allocated on the STACK
object1 = object2;//!!!! This is different! The CONTENTS of object2 are COPIED onto object1,
//using the "copy assignment operator", the definition of operator =.
//But, the two objects are still different. Change one, the other remains unchanged.
//Also, the objects get automatically destroyed once the function returns...

그것을 생각하는 가장 좋은 방법은 Java가 객체에 대한 포인터를 암시 적으로 처리하는 반면 C ++은 객체에 대한 포인터 또는 객체 자체를 처리 할 수 ​​있다는 것입니다. 여기에는 예외가 있습니다. 예를 들어 Java "primitive"유형을 선언하는 경우 포인터가 아니라 복사 된 실제 값입니다. 그래서,

자바:

int object1; //An integer is allocated on the stack.
int object2; //Another integer is allocated on the stack.
object1 = object2; //The value of object2 is copied to object1.

즉, 포인터를 사용하는 것이 반드시 물건을 처리하는 올바른 방법이거나 잘못된 방법은 아닙니다. 그러나 다른 답변은 만족스럽게 다루었습니다. 그러나 일반적인 아이디어는 C ++에서 객체의 수명과 객체의 위치를 ​​훨씬 더 많이 제어 할 수 있다는 것입니다.

요점 Object * object = new Object()은 실제로 일반적인 Java (또는 해당 C #) 의미에 가장 가까운 구문입니다.

포인터를 사용하는 또 다른 좋은 이유는 앞으로 선언하는 것 입니다. 충분히 큰 프로젝트에서 실제로 컴파일 시간을 단축시킬 수 있습니다.

머리말

자바는 과대 광고와 달리 C ++과는 다릅니다. Java 과장 기계는 Java가 C ++과 같은 구문을 가지고 있기 때문에 언어가 유사하다고 생각합니다. 진실에서 더 이상 갈 수있는 것은 없습니다. 이 잘못된 정보는 Java 프로그래머가 코드의 의미를 이해하지 않고 C ++로 이동하여 Java와 유사한 구문을 사용하는 이유의 일부입니다.

앞으로 우리는 간다

그러나 왜 우리가 이런 식으로 해야하는지 알 수 없습니다. 메모리 주소에 직접 액세스 할 수 있기 때문에 효율성과 속도와 관련이 있다고 가정합니다. 내가 맞아?

반대로, 실제로. 스택은 힙에 비해 매우 단순하므로 힙이 스택보다 훨씬 느립니다 . 자동 저장 변수 (일명 스택 변수)는 소멸자가 범위를 벗어나면 호출됩니다. 예를 들면 다음과 같습니다.

{
    std::string s;
}
// s is destroyed here

반면 동적으로 할당 된 포인터를 사용하는 경우 소멸자를 수동으로 호출해야합니다. delete이 소멸자를 호출합니다.

{
    std::string* s = new std::string;
}
delete s; // destructor called

이것은 newC # 및 Java에서 널리 사용되는 구문 과 관련이 없습니다 . 그것들은 완전히 다른 목적으로 사용됩니다.

동적 할당의 이점

1. 사전에 배열의 크기를 알 필요가 없습니다

많은 C ++ 프로그래머가 겪는 첫 번째 문제 중 하나는 사용자의 임의 입력을 받아 들일 때 스택 변수에 고정 된 크기 만 할당 할 수 있다는 것입니다. 배열의 크기도 변경할 수 없습니다. 예를 들면 다음과 같습니다.

char buffer[100];
std::cin >> buffer;
// bad input = buffer overflow

물론, std::string대신 사용하면 std::string내부적으로 크기가 조정되므로 문제가되지 않습니다. 그러나 본질적으로이 문제에 대한 해결책은 동적 할당입니다. 예를 들어, 사용자의 입력을 기반으로 동적 메모리를 할당 할 수 있습니다.

int * pointer;
std::cout << "How many items do you need?";
std::cin >> n;
pointer = new int[n];

참고 : 많은 초보자들이 실수로하는 실수 중 하나는 가변 길이 배열의 사용입니다. 이것은 GNU 확장이며 Clang의 확장이기도합니다. 많은 GCC 확장을 반영하기 때문입니다. 따라서 다음에 int arr[n]의존해서는 안됩니다.

힙이 스택보다 훨씬 크기 때문에 필요한만큼의 메모리를 임의로 할당 / 재 할당 할 수 있지만 스택에는 제한이 있습니다.

2. 배열은 포인터가 아니다

이것이 당신이 요구하는 이점은 무엇입니까? 배열과 포인터의 혼란과 신화를 이해하면 대답이 명확해질 것입니다. 일반적으로 동일한 것으로 가정하지만 그렇지 않습니다. 이 신화는 포인터가 배열처럼 첨자 화 될 수 있고 함수 선언에서 최상위 레벨의 포인터로 배열이 소멸 될 수 있다는 사실에서 비롯됩니다. 그러나 배열이 포인터로 붕괴되면 포인터가 sizeof정보를 잃게 됩니다. 따라서 sizeof(pointer)64 비트 시스템에서 일반적으로 8 바이트 인 포인터 크기를 바이트 단위로 제공합니다.

배열은 할당 할 수 없으며 초기화 만합니다. 예를 들면 다음과 같습니다.

int arr[5] = {1, 2, 3, 4, 5}; // initialization 
int arr[] = {1, 2, 3, 4, 5}; // The standard dictates that the size of the array
                             // be given by the amount of members in the initializer  
arr = { 1, 2, 3, 4, 5 }; // ERROR

반면에 포인터로 원하는 것을 할 수 있습니다. 불행히도, 포인터와 배열의 구별은 Java와 C #에서 수동으로 이루어지기 때문에 초보자는 그 차이를 이해하지 못합니다.

3. 다형성

Java 및 C #에는 as키워드 를 사용하여 객체를 다른 객체로 취급 할 수있는 기능이 있습니다 . 누군가가 치료 싶어한다면 EntityA와 객체를 Player객체, 사람은 할 수있는 Player player = Entity as Player;경우에만 특정 유형에 적용해야 균일 한 용기에 함수를 호출하려는 경우에 매우 유용합니다. 기능은 아래와 비슷한 방식으로 달성 될 수 있습니다.

std::vector<Base*> vector;
vector.push_back(&square);
vector.push_back(&triangle);
for (auto& e : vector)
{
     auto test = dynamic_cast<Triangle*>(e); // I only care about triangles
     if (!test) // not a triangle
        e.GenericFunction();
     else
        e.TriangleOnlyMagic();
}

따라서 Triangles에만 Rotate 함수가 있으면 클래스의 모든 객체에서 호출하려고하면 컴파일러 오류가 발생합니다. 를 사용 dynamic_cast하면 as키워드를 시뮬레이션 할 수 있습니다 . 명확하게 말하면, 캐스트가 실패하면 유효하지 않은 포인터를 반환합니다. 따라서 !test본질적으로 testNULL 또는 유효하지 않은 포인터인지 확인하기위한 약칭으로 , 캐스트가 실패했음을 의미합니다.

자동 변수의 장점

동적 할당이 할 수있는 모든 위대한 일을보고 나면 왜 동적 할당을 항상 사용하지 않는 사람이 있는지 궁금 할 것입니다. 나는 이미 한 가지 이유를 말했지만 힙이 느립니다. 모든 메모리가 필요하지 않은 경우 남용해서는 안됩니다. 따라서 특별한 순서가없는 몇 가지 단점이 있습니다.

• 오류가 발생하기 쉽습니다. 수동 메모리 할당은 위험하며 누수가 발생하기 쉽습니다. 디버거 나 valgrind(메모리 누수 도구) 사용에 능숙하지 않으면 머리카락을 머리에서 빼낼 수 있습니다. 운 좋게도 RAII 관용구와 똑똑한 포인터는 이것을 조금 완화하지만, Rule of Three와 The Rule Of Five와 같은 관행에 익숙해야합니다. 많은 정보가 필요하며, 모르거나 신경 쓰지 않는 초보자는이 함정에 빠질 것입니다.

• 필요하지 않습니다. new모든 곳 에서 키워드 를 사용하는 것이 관용 인 Java 및 C #과 달리 C ++에서는 필요한 경우에만 사용해야합니다. 일반적인 문구는 망치가 있으면 모든 것이 못처럼 보입니다. C ++로 시작하는 초보자는 포인터가 무섭고 습관적으로 스택 변수를 사용하는 법을 배우는 반면 Java 및 C # 프로그래머는 포인터를 이해하지 않고 포인터를 사용하여 시작 합니다! 말 그대로 잘못된 발을 밟고 있습니다. 구문은 하나이고 언어를 배우는 것은 다른 것이므로 아는 모든 것을 버려야합니다.

1. (N) RVO-일명, (명명 된) 반환 값 최적화

많은 컴파일러가 만드는 최적화 중 하나는 elision 및 return value optimization 입니다. 이러한 것들은 많은 요소를 포함하는 벡터와 같이 매우 큰 객체에 유용한 불필요한 사본을 피할 수 있습니다. 일반적으로 큰 개체를 복사하여 이동 하지 않고 포인터를 사용하여 소유권 을 이전 하는 것이 일반적 입니다. 이것은 이동 의미론 과 스마트 포인터 의 시작으로 이어졌다 .

포인터를 사용하는 경우 (N) RVO가 발생 하지 않습니다 . 최적화가 걱정되면 포인터를 반환하거나 전달하는 것보다 (N) RVO를 이용하는 것이 더 유리하고 오류가 적은 경향이 있습니다. 함수의 호출자가 delete동적으로 할당 된 객체 등을 담당하는 경우 오류가 발생할 수 있습니다 . 포인터가 핫 포테이토처럼지나 가면 객체의 소유권을 추적하기가 어려울 수 있습니다. 스택 변수는 더 단순하고 우수하므로 사용하십시오.

C ++은 포인터, 참조 및 값으로 객체를 전달하는 세 가지 방법을 제공합니다. Java는 후자를 제한합니다 (int, boolean 등의 기본 유형은 예외입니다). 이상한 장난감이 아닌 C ++을 사용하려면이 세 가지 방법의 차이점을 이해하는 것이 좋습니다.

자바는 '누가 언제 언제 이것을 파괴해야 하는가?'와 같은 문제가 없다고 주장한다. 대답은 가비지 컬렉터, 위대하고 끔찍합니다. 그럼에도 불구하고 메모리 누수에 대해 100 % 보호 기능을 제공 할 수 없습니다 (예, java 는 메모리 누수 가능 ). 실제로 GC는 잘못된 안전 감각을 제공합니다. SUV가 클수록 진공 청소기로가는 길이 길어집니다.

C ++는 객체의 수명주기 관리와 직접 대면합니다. 스마트 포인터 제품군, Qt의 QObject 등 을 다루는 방법이 있지만 GC와 같은 '화재 및 잊어 버림'방식으로 사용할 수는 없습니다. 항상 메모리 처리를 명심 해야합니다 . 물체를 파괴하는 것에주의해야 할뿐만 아니라 같은 물체를 두 번 이상 파괴하지 않아야합니다.

아직 두렵지 않습니까? Ok : 순환 참조-스스로 처리하십시오. 그리고 기억하십시오 : 각 객체를 정확히 한 번 죽이면 C ++ 런타임은 시체를 엉망으로 만드는 사람들을 좋아하지 않으며 죽은 것을 혼자 남겨 둡니다.

다시 질문으로 돌아가십시오.

포인터 나 참조가 아닌 값으로 객체를 전달할 때 객체를 복사합니다 (전체 객체는 몇 바이트이든 큰 데이터베이스 덤프이든 관계없이 후자를 피할만큼 똑똑합니다). 당신은?) 할 때마다 '='. 그리고 객체의 멤버에 액세스하려면 '.' (점).

포인터로 객체를 전달하면 몇 바이트 (32 비트 시스템의 경우 4, 64 비트 시스템의 경우 8), 즉이 객체의 주소 만 복사합니다. 그리고 이것을 모든 사람에게 보여주기 위해 회원에게 접근 할 때이 멋진 '->'연산자를 사용합니다. 또는 '*'와 '.'의 조합을 사용할 수 있습니다.

참조를 사용하면 값을 가장하는 포인터가 나타납니다. 포인터이지만 '.'을 통해 멤버에 액세스합니다.

그리고 한 번 더 마음을 불어 넣으려면 쉼표로 구분 된 여러 변수를 선언하면 (손을보십시오) :

• 유형은 모든 사람에게 주어집니다
• 값 / 포인터 / 참조 수정자는 개별적입니다

예:

struct MyStruct
{
    int* someIntPointer, someInt; //here comes the surprise
    MyStruct *somePointer;
    MyStruct &someReference;
};

MyStruct s1; //we allocated an object on stack, not in heap

s1.someInt = 1; //someInt is of type 'int', not 'int*' - value/pointer modifier is individual
s1.someIntPointer = &s1.someInt;
*s1.someIntPointer = 2; //now s1.someInt has value '2'
s1.somePointer = &s1;
s1.someReference = s1; //note there is no '&' operator: reference tries to look like value
s1.somePointer->someInt = 3; //now s1.someInt has value '3'
*(s1.somePointer).someInt = 3; //same as above line
*s1.somePointer->someIntPointer = 4; //now s1.someInt has value '4'

s1.someReference.someInt = 5; //now s1.someInt has value '5'
                              //although someReference is not value, it's members are accessed through '.'

MyStruct s2 = s1; //'NO WAY' the compiler will say. Go define your '=' operator and come back.

//OK, assume we have '=' defined in MyStruct

s2.someInt = 0; //s2.someInt == 0, but s1.someInt is still 5 - it's two completely different objects, not the references to the same one

C ++에서 스택에 할당 된 객체 ( Object object;블록 내 명령문 사용 )는 선언 된 범위 내에서만 존재합니다. 코드 블록이 실행을 마치면 선언 된 객체가 파괴됩니다. 을 사용하여 힙에 메모리를 할당하는 경우을 Object* obj = new Object()호출 할 때까지 메모리는 계속 힙에 유지 delete obj됩니다.

선언 / 할당 된 코드 블록뿐만 아니라 객체를 사용하고 싶을 때 힙에 객체를 만듭니다.

그러나 왜 우리가 이것을 사용해야하는지 알 수 없습니다.

다음을 사용하면 함수 본문 내에서 어떻게 작동하는지 비교합니다.

Object myObject;

함수 내부 myObject에서이 함수가 반환되면 파괴됩니다. 따라서 함수 외부에서 객체가 필요하지 않은 경우에 유용합니다. 이 객체는 현재 스레드 스택에 배치됩니다.

함수 본문 안에 쓰는 경우 :

 Object *myObject = new Object;

myObject함수가 종료되고 할당이 힙에 있으면 객체가 가리키는 객체 클래스 인스턴스 가 소멸되지 않습니다.

Java 프로그래머라면 두 번째 예는 Java에서 객체 할당이 작동하는 방식에 더 가깝습니다. 이 줄 Object *myObject = new Object;은 java :와 같습니다 Object myObject = new Object();. 차이점은 java myObject에서는 가비지 수집이 이루어지고 c ++에서는 해제되지 않으므로 명시 적으로`delete myObject; 그렇지 않으면 메모리 누수가 발생합니다.

c ++ 11부터는 new Objectshared_ptr / unique_ptr에 값을 저장 하여 안전한 동적 할당 방법을 사용할 수 있습니다 .

std::shared_ptr<std::string> safe_str = make_shared<std::string>("make_shared");

// since c++14
std::unique_ptr<std::string> safe_str = make_unique<std::string>("make_shared"); 

또한 객체는 맵 또는 벡터와 같은 컨테이너에 저장되는 경우가 많으며 객체의 수명을 자동으로 관리합니다.

기술적으로 이것은 메모리 할당 문제이지만 여기에 두 가지 더 실용적인 측면이 있습니다. 1) 범위, 포인터없이 객체를 정의하면 코드 블록이 정의 된 후에는 더 이상 액세스 할 수 없지만 "new"로 포인터를 정의하면 같은 포인터에서 "삭제"를 호출 할 때까지이 메모리에 대한 포인터가있는 어느 곳에서나 액세스 할 수 있습니다. 2) 함수에 인수를 전달하려면보다 효율적으로 포인터 또는 참조를 전달하려고합니다. 객체를 전달하면 객체가 복사됩니다. 많은 메모리를 사용하는 객체 인 경우 CPU를 소모 할 수 있습니다 (예 : 벡터로 데이터를 복사). 포인터를 전달하면 전달하는 것은 1 int입니다 (구현에 따라 다르지만 대부분 int입니다).

그 외에는 "new"가 특정 시점에 해제해야하는 힙에 메모리를 할당한다는 것을 이해해야합니다. "새"를 사용할 필요가없는 경우 "스택에서"일반 개체 정의를 사용하는 것이 좋습니다.

주된 질문은 왜 객체 자체보다는 포인터를 사용해야합니까? 그리고 내 대답은 객체 대신 포인터를 사용하지 않아야합니다 .C ++에는 참조 가 있기 때문에 포인터보다 안전하고 포인터와 동일한 성능을 보장합니다.

당신이 당신의 질문에 언급 한 또 다른 것 :

Object *myObject = new Object;

어떻게 작동합니까? 그것은 Object유형의 포인터를 만들고 , 하나의 객체에 맞게 메모리를 할당하고 기본 생성자를 호출합니다. 그러나 실제로 메모리가 좋지 않은 경우 (키워드 사용 new) 메모리를 수동으로 해제해야합니다. 즉, 코드에서 다음을 가져야합니다.

delete myObject;

이것은 소멸자를 호출하고 메모리를 해제하고 쉽게 보입니다. 그러나 큰 프로젝트에서는 하나의 스레드가 메모리를 해제했는지 여부를 감지하기 어려울 수 있지만 공유 목적을 시도 하면 성능이 약간 저하되지만 작업하기가 훨씬 쉽습니다. 그들.

이제 소개가 끝났고 다시 질문으로 돌아갑니다.

함수 대신 데이터를 전송하는 동안 성능을 높이기 위해 객체 대신 포인터를 사용할 수 있습니다.

살펴보면 std::string(객체이기도 함) 큰 XML과 같은 많은 양의 데이터가 포함되어 있으므로 구문 분석해야하지만 void foo(...)다른 방법으로 선언 할 수있는 기능 이 있습니다.

1. void foo(std::string xml); 이 경우 변수의 모든 데이터를 함수 스택으로 복사하면 시간이 걸리므로 성능이 저하됩니다.
2. void foo(std::string* xml); 이 경우 size_t변수 전달과 동일한 속도로 객체에 포인터를 전달 하지만 NULL포인터 또는 유효하지 않은 포인터를 전달할 수 있기 때문에이 선언에 오류가 발생하기 쉽습니다 . C참조가 없기 때문에 일반적으로 사용되는 포인터 .
3. void foo(std::string& xml); 여기에서는 참조를 전달합니다. 기본적으로 포인터를 전달하는 것과 동일하지만 컴파일러는 일부 작업을 수행하고 유효하지 않은 참조를 전달할 수 없습니다 (실제로 유효하지 않은 참조로 상황을 만들 수는 있지만 컴파일러를 속이는 것입니다).
4. void foo(const std::string* xml); 두 번째와 동일하며 포인터 값만 변경할 수 없습니다.
5. void foo(const std::string& xml); 여기는 세 번째와 동일하지만 객체 값을 변경할 수 없습니다.

더 언급하고 싶은 것은, 당신이 선택한 할당 방법 (with new또는 regular )에 관계없이이 5 가지 방법을 사용하여 데이터를 전달할 수 있습니다 .

언급해야 할 또 다른 사항은 정기적 으로 객체를 만들 때 스택에 메모리를 할당하지만 new힙을 할당 하면서 메모리 를 할당하는 것입니다. 스택을 할당하는 것이 훨씬 빠르지 만 실제로 큰 데이터 배열의 경우 크기가 작으므로 큰 객체가 필요한 경우 스택 오버플로가 발생할 수 있으므로 힙을 사용해야하지만 일반적 으로이 문제는 STL 컨테이너를 사용하여 해결 되고 기억하십시오. std::string또한 컨테이너이며 일부 사람들은 그것을 잊었습니다 :)

당신이 class A포함하고 있다고 가정 해 봅시다 외부의 class B함수를 호출하고 싶을 때이 클래스에 대한 포인터를 얻으면 원하는대로 무엇이든 할 수 있으며 컨텍스트의 컨텍스트가 변경 됩니다.class Bclass Aclass Bclass A

그러나 동적 객체에주의하십시오.

객체에 대한 포인터를 사용하면 많은 이점이 있습니다.

1. 효율성 (이미 지적한대로). 객체를 함수에 전달한다는 것은 객체의 새로운 사본을 만드는 것을 의미합니다.
2. 타사 라이브러리의 객체 작업 객체가 타사 코드에 속하고 작성자가 포인터 만 사용하여 (복사 생성자 등이 아닌) 객체를 사용하려는 경우이 객체를 전달할 수있는 유일한 방법은 포인터를 사용하는 것입니다. 값으로 전달하면 문제가 발생할 수 있습니다. (깊은 복사 / 얕은 복사 문제).
3. 개체가 리소스를 소유하고 있고 다른 개체와 소유권을 공유해서는 안되는 경우

이것은 오랫동안 논의되었지만 Java에서는 모든 것이 포인터입니다. 스택 할당과 힙 할당 (모든 객체가 힙에 할당 됨)을 구분하지 않으므로 포인터를 사용하고 있다는 사실을 모릅니다. C ++에서는 메모리 요구 사항에 따라 두 가지를 혼합 할 수 있습니다. C ++ (duh)에서 성능 및 메모리 사용량이보다 결정적입니다.

Object *myObject = new Object;

이렇게하면 메모리 누수 를 피하기 위해 명시 적으로 삭제해야하는 객체 (힙에서)에 대한 참조가 생성됩니다 .

Object myObject;

이렇게하면 자동 유형 (스택)의 객체 (myObject)가 생성되어 객체 (myObject)가 범위를 벗어날 때 자동으로 삭제됩니다.

포인터는 객체의 메모리 위치를 직접 참조합니다. 자바에는 이런 것이 없습니다. Java에는 해시 테이블을 통해 객체의 위치를 ​​참조하는 참조가 있습니다. 이러한 참조를 사용하여 Java에서 포인터 산술과 같은 작업을 수행 할 수 없습니다.

귀하의 질문에 대답하기 위해서는 귀하가 선호하는 것입니다. Java와 같은 구문을 선호합니다.

포인터 로

• 직접 메모리와 대화 할 수 있습니다.

• 포인터를 조작하여 프로그램의 많은 메모리 누수를 방지 할 수 있습니다.

포인터를 사용하는 한 가지 이유는 C 함수와 인터페이스하기위한 것입니다. 또 다른 이유는 메모리를 절약하는 것입니다. 예를 들어, 많은 데이터를 포함하고 프로세서 중심의 복사 생성자를 가진 객체를 함수에 전달하는 대신 객체에 포인터를 전달하면 특히 루프에있는 경우 메모리와 속도를 절약 할 수 있습니다. 이 경우 C 스타일 배열을 사용하지 않는 한 참조가 더 좋습니다.

메모리 사용률이 가장 높은 영역에서는 포인터가 편리합니다. 예를 들어, 재귀적인 루틴을 사용하여 수천 개의 노드가 생성되는 미니 맥스 알고리즘을 고려한 다음,이 노드를 사용하여 게임에서 다음 최고 이동, 스마트 포인터에서와 같이 할당 해제 또는 재설정 기능을 사용하여 메모리 소비를 크게 줄입니다. 비 포인터 변수는 재귀 호출이 값을 반환 할 때까지 공간을 계속 차지합니다.

포인터의 중요한 사용 사례 하나를 포함하겠습니다. 기본 클래스에 일부 객체를 저장하고 있지만 다형성 일 수 있습니다.

Class Base1 {
};

Class Derived1 : public Base1 {
};


Class Base2 {
  Base *bObj;
  virtual void createMemerObects() = 0;
};

Class Derived2 {
  virtual void createMemerObects() {
    bObj = new Derived1();
  }
};

따라서이 경우 bObj를 직접 객체로 선언 할 수 없으므로 포인터가 있어야합니다.

"필요는 발명의 어머니이다." 내가 지적하고 싶은 가장 중요한 차이점은 코딩 경험의 결과입니다. 때로는 객체를 함수에 전달해야합니다. 이 경우 객체가 매우 큰 클래스 인 경우 객체로 전달하면 객체의 상태가 복사됩니다 (원치 않을 수 있습니다. .. 그리고 너무 큼직 할 수 있음). 복사 객체의 오버 헤드가 발생합니다. 4 바이트 크기 (32 비트로 가정). 다른 이유는 이미 위에서 언급했습니다 ...

이미 훌륭한 답변이 많이 있지만 한 가지 예를 들어 보겠습니다.

간단한 Item 클래스가 있습니다.

 class Item
    {
    public: 
      std::string name;
      int weight;
      int price;
    };

나는 그것들을 잔뜩 담을 벡터를 만듭니다.

std::vector<Item> inventory;

백만 개의 Item 객체를 만들고 벡터로 다시 밀어 넣습니다. 벡터를 이름별로 정렬 한 다음 특정 항목 이름에 대한 간단한 반복 이진 검색을 수행합니다. 프로그램을 테스트했는데 실행을 마치는 데 8 분이 걸립니다. 그런 다음 인벤토리 벡터를 다음과 같이 변경합니다.

std::vector<Item *> inventory;

... 새로운 것을 통해 백만 개의 Item 객체를 만듭니다. 내가 코드를 변경하는 유일한 것은 마지막에 메모리 정리를 위해 추가 한 루프를 제외하고 항목에 대한 포인터를 사용하는 것입니다. 이 프로그램은 40 초 이내에 실행되거나 10 배 속도 증가보다 우수합니다. 편집 : 코드는 http://pastebin.com/DK24SPeW에 있습니다 . 컴파일러 최적화를 사용하면 방금 테스트 한 컴퓨터에서 3.4 배 증가한 것으로 나타났습니다.