표현식에는 클래스 유형이 있어야합니다.

나는 한동안 C ++로 코딩하지 않았고이 간단한 스 니펫을 컴파일하려고 할 때 막혔습니다.

class A
{
  public:
    void f() {}
};

int main()
{
  {
    A a;
    a.f(); // works fine
  }

  {
    A *a = new A();
    a.f(); // this doesn't
  }
}

포인터이므로 대신 시도하십시오.

a->f();

기본적으로 연산자 .(객체의 필드와 메서드에 액세스하는 데 사용됨)는 객체와 참조에 사용됩니다.

A a;
a.f();
A& ref = a;
ref.f();

포인터 유형이있는 경우 참조를 얻으려면 먼저 참조를 역 참조해야합니다.

A* ptr = new A();
(*ptr).f();
ptr->f();

a->b표기는 일반적으로 단지 속기이다 (*a).b.

스마트 포인터에 대한 참고 사항

은 operator->오버로드 될 수 있으며 특히 스마트 포인터에서 사용됩니다. 때 당신이 스마트 포인터를 사용하고 , 당신은 또한 사용 ->뾰족한 물체를 참조 :

auto ptr = make_unique<A>();
ptr->f();

분석을 허용하십시오.

#include <iostream>   // not #include "iostream"
using namespace std;  // in this case okay, but never do that in header files

class A
{
 public:
  void f() { cout<<"f()\n"; }
};

int main()
{
 /*
 // A a; //this works
 A *a = new A(); //this doesn't
 a.f(); // "f has not been declared"
 */ // below


 // system("pause");  <-- Don't do this. It is non-portable code. I guess your 
 //                       teacher told you this?
 //                       Better: In your IDE there is prolly an option somewhere
 //                               to not close the terminal/console-window.
 //                       If you compile on a CLI, it is not needed at all.
}

일반적인 조언 :

0) Prefer automatic variables
  int a;
  MyClass myInstance;
  std::vector<int> myIntVector;

1) If you need data sharing on big objects down 
   the call hierarchy, prefer references:

  void foo (std::vector<int> const &input) {...}
  void bar () { 
       std::vector<int> something;
       ...
       foo (something);
  }


2) If you need data sharing up the call hierarchy, prefer smart-pointers
   that automatically manage deletion and reference counting.

3) If you need an array, use std::vector<> instead in most cases.
   std::vector<> is ought to be the one default container.

4) I've yet to find a good reason for blank pointers.

   -> Hard to get right exception safe

       class Foo {
           Foo () : a(new int[512]), b(new int[512]) {}
           ~Foo() {
               delete [] b;
               delete [] a;
           }
       };

       -> if the second new[] fails, Foo leaks memory, because the
          destructor is never called. Avoid this easily by using 
          one of the standard containers, like std::vector, or
          smart-pointers.

경험상 메모리를 직접 관리해야하는 경우 일반적으로 RAII 원칙을 따르는 우수한 관리자 또는 대안이 이미 있습니다.

요약 : 대신에 a.f();그것이 있어야a->f();

주에서 당신은 정의 을 에 대한 포인터로 의 객체 당신이 사용하는 기능에 액세스 할 수 있도록, 연산자를.->

다른 ,하지만 덜 읽을 수있는 방법입니다(*a).f()

a.f()a 가 다음과 같이 선언 된 경우 f ()에 액세스하는 데 사용할 수 있습니다 . A a;

a포인터입니다. 을 사용해야합니다 ->..