Expressie moet klassetype hebben

Ik heb een tijdje niet gecodeerd in c++ en ik liep vast toen ik dit eenvoudige fragment probeerde te compileren:

class A
{
  public:
    void f() {}
};
int main()
{
  {
    A a;
    a.f(); // works fine
  }
  {
    A *a = new A();
    a.f(); // this doesn't
  }
}

Antwoord 1, autoriteit 100%

Het is een aanwijzer, dus probeer in plaats daarvan:

a->f();

In principe wordt de operator .(gebruikt om toegang te krijgen tot de velden en methoden van een object) gebruikt op objecten en verwijzingen, dus:

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

Als u een aanwijzertype heeft, moet u deze eerst dereferentie hebben om een ​​referentie te verkrijgen:

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

De a->b-notatie is meestal slechts een afkorting voor (*a).b.

Een opmerking over slimme aanwijzers

De operator->kan overbelast worden, wat met name wordt gebruikt door slimme aanwijzers. Wanneer je slimme aanwijzers gebruikt, dan gebruik je ook ->om naar het puntige object te verwijzen:

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

Antwoord 2, autoriteit 9%

Een analyse toestaan.

#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.
}

Als algemeen advies:

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.

Vuistregel: als u het geheugen zelf moet beheren, is er over het algemeen al een superieure manager of alternatief beschikbaar, een die het RAII-principe volgt.

Antwoord 3, autoriteit 6%

Samenvatting: in plaats van a.f();moet het a->f();

zijn

In het algemeen heb je agedefinieerd als een aanwijzer naar object vanA, zodat je toegang krijgt tot functies met de ->operator.

Een alternatieve, maar minder leesbare manier is (*a).f()

a.f()had kunnen worden gebruikt om toegang te krijgen tot f(), als awas gedeclareerd als:
A a;

Antwoord 4, autoriteit 4%

ais een aanwijzer. U moet ->gebruiken, niet .