Unterschied zwischen -> und . bei Klassenfunktionsaufruf?

Hi,

Ich kann die Funktionen einer Klasse ja entweder aufrufen indem ich einen Zeiger auf die Klasse erzeuge und dann mit -> auf sie zugreife.
Oder ich erzeuge ein Element der Klasse und benutze dann den . Operator!

Also 1:

CMyClass *pointer;

pointer->Variable = 4;

Oder 2:
CMyClass Klasse
Klasse.Variable = 4;

Wo ist da der Unterschied?

Danke schonmal!
mfg frogi

Nirgends, was die Zugriffsart anbelangt.

Das hier:
pointer->Variable = 4;
könnte auch:
(*pointer).Variable = 4;
heissen, da aber geklammert werden muss nimmt man den -> operator,
der auch gleich dereferenziert. Du greifst also auch bei einem pointer
mit dem Punkt operator auf eine Element/Methode zu, aber das -> spart dir
das dereferenzieren und die Klammer.

MfG Max

Shlo

1 ist schonmal falsch, denn der Zeiger muss irgendwohin zeigen. Richtig wäre:

MyClass* p = new MyClass;
p->a = 5;
//...
delete p;

somit existiert das Objekt, bis du delete oder explizit den Destruktor aufrufst. Bei der zweiten Variante erzeugst du das Objekt auf dem Stack. Nach dem Verlassen des Scopes, wird es automatisch zerstört (auto Objekt).

Hi,

Danke für die Antworten,
Also so wie ich das Verstehe erzeugt mir die korrigierte 1 Art ein Objekt der Klasse MyClass, das ich dann auch wieder löschen muss(kann).

Beim 2. Beispiel wird auch ein Objekt "Klasse" der Klasse MyClass erzeugt aber wann ist dieses nicht mehr gültig?
Was genau bedeutet daß es nach Verlassen des Scopes zerstört wird?

mfg frogi

Ersteinmal sorry wegen der falschen Auskunft von vorhin.

frogi schrieb:

Also so wie ich das Verstehe erzeugt mir die korrigierte 1 Art ein Objekt der Klasse MyClass, das ich dann auch wieder löschen muss(kann).

Richtig.

frogi schrieb:

Beim 2. Beispiel wird auch ein Objekt "Klasse" der Klasse MyClass erzeugt aber wann ist dieses nicht mehr gültig?
Was genau bedeutet daß es nach Verlassen des Scopes zerstört wird?

Ein scope ist folgendes:

{
// Scope
}

Wenn ich in dem Scope i definiere:

{
int i;
}// Dann wird am Scope ende i gelöscht!
// hier existiert i nicht mehr

Ein kleines Beispiel Programm (wenn einem langweilig ist ):

#include <iostream>

class Frau{
private:
int m_HaarFarbeR;
int m_HaarFarbeG;
int m_HaarFarbeB;
public:
    Frau(int HaarFarbeR,int HaarFarbeG,int HaarFarbeB)
    : m_HaarFarbeR(HaarFarbeR),
      m_HaarFarbeG(HaarFarbeG),
      m_HaarFarbeB(HaarFarbeB)
    {
    }

    ~Frau(){
    }

    void PrintHaarFarbe(){
    std::cout << m_HaarFarbeR << ','
              << m_HaarFarbeG << ',' 
              << m_HaarFarbeB << std::endl;
    }
};

int main(int argc, char *argv[])
{

Frau *SchwarzHaarigeFrau = new Frau(0,0,0);
std::cout << "Schwarz Haarige Frau: ";
// zugriff über Pfeiloperator:
      SchwarzHaarigeFrau->PrintHaarFarbe();

    {// neuer scope
    Frau RotHaarigeFrau(255,0,0);
    std::cout << "Rot Haarige Frau: ";
    // zugriff über Punktoperator:
        RotHaarigeFrau.PrintHaarFarbe();
    }// scope ende RotHaarigeFrau wird zerstört

// RotHaarigeFrau.PrintHaarFarbe(); Würde Fehler geben, dar das Objekt nicht mehr existiert!

 delete SchwarzHaarigeFrau; // lösche Objekt, dieses Objekt würde auch scopes überleben!

 std::cin.get();
  return 0;
}

Ich hoffe diesmal nicht falsche Auskunft gegeben zu haben. -nocheinmal sorry.

MfG Max

Mis2com

[klugscheiß]

1 ist schonmal falsch, denn der Zeiger muss irgendwohin zeigen. Richtig währe:

Falsch, richtig wäre: Richtig wäre:
[/klugscheiß]

Shlo

das erste Mal, dass ich wäre falsch geschrieben habe.
(oh Gott, wie peinlich )

Hi,

Ok damit ist das jetzt klar, Danke euch allen

@Master_Max :

Nettes Beispielprogramm, hab nur noch ne kleine Frage dazu:

Die Wertübergabe im Konstuktor:

: m_HaarFarbeR(HaarFarbeR),
m_HaarFarbeG(HaarFarbeG),
m_HaarFarbeB(HaarFarbeB)

hab ich noch nie gesehen wie geht daß?
wieso schreibt er die HaarFarbeR auf m_HaarFarbeR?

mfg frogi

Der Konstruktor ist in diesem Fall ein Elemente-Initialisierer.
Die Attribute der Klasse haben das m_ zur kennzeichnung und damit
ich mit den Parametern des Konstruktors keine Probleme bekomme.

Frau(int HaarFarbeR,int HaarFarbeG,int HaarFarbeB)
    : m_HaarFarbeR(HaarFarbeR), // Ganz normale Wert zuweisungen
      m_HaarFarbeG(HaarFarbeG), // bis darauf, das man damit im gegensatz zu
      m_HaarFarbeB(HaarFarbeB) // normalen zuweisungen, auch const zuweisen kann!
    {
    // eine Konst Variable könnte ich hier nicht zuweisen!
    }

MfG Max

Unterschied zwischen -&gt; und . bei Klassenfunktionsaufruf?

Unterschied zwischen -> und . bei Klassenfunktionsaufruf?