mir ist bei einem kleinen Beispiel folgendes aufgefallen:

#include <iostream>
using namespace std;

class A
{
    private:
        int x;

    public:
        A();
        A(int);
        A& operator=(const A &);
        A(const A&);

};

A::A() : x(0) {}

A::A(int x)
{
    cout << endl << "zuweisungs constructor" << endl;
    this->x=x;
}

A& A::operator=(const A &obj)
{
    cout << endl << "=" << endl;
    this->x=obj.x;
    return *this;
}

A::A(const A& obj)
{
    cout << endl << "copy" << endl;
    this->x=obj.x;
}

int main()
{
    A a=5;
    A b(5);
    // Nun wurde 2x der Zuweisungskonstruktor aufgerufen.
    // Ist dann also "=" und "(5)" für den  Compiler gleichbedeutend ???

    A c=a;
    A d(a);
    // Hier wurde nun 2x der Copy Constructor aufgerufen
    // Ist dies für den Compiler dann auch gleichbedeutend ???

    A e;
    e=a;
    // Hier wird aber nun die Zuweisungsoperator Funktion auferufen
    /* 
       Warum unterscheidet der Compiler zwischen einer Anfangsinitalisierung
       und einer Initalisierung im Nachhinein ???
    */

    A f;
    f=5;
    /*
       Hier wurde nun der Zuweisungskonstruktor
       und danach noch die Zuweisungsoperator Funktion.
       Hier unterscheidet der Compiler also auch zwischen 1. A f=5 
       und 2. A f; f=5;
       was mich wieder zu der Frage oberhalb führt.

      Was mir noch unverständlicher is warum er bei der 1.Version
      nur 1 Funktionsaufruf braucht, bei der 2.Version aber 2???
   */

   system("pause>nul");
   return 0;
}

Hoff es ist in Ordnung wenn die Fragen im Quelltext stehn
Danke euch schonmal im Voraus

Dweb schrieb:

...

/* 
       Warum unterscheidet der Compiler zwischen einer Anfangsinitalisierung
       und einer Initalisierung im Nachhinein ???
    */

...

Ganz einfach: Weil es Zweiteres nicht gibt.
Eine Initialisierung ist eben "initial" ... also "anfänglich" (weswegen der Begriff "Anfangsinitialisierung" gelinde gesagt unüblich ist).

Was Du da betreibst ist eine Zuweisung und für die wird in C++ - Wunder über Wunder - der Zuweisungsoperator verwendet.
Mach Dir aber nichts draus: Das ist ein relativ typischer Denkfehler (dem vermutlich jeder irgendwie mal aufsitzt), dass doch alles, was in bestimmten Konstellationen zum selben Ergebnis führt, auch prinzipiell dasselbe sei.
(Hier halt: "Initialisierung mit 5" und "Defaultinitialisierung und Zuweisung von 5")
... und erst im Laufe der Zeit sieht man irgendwann Konstellationen, in denen die Dinge ihre Unterschiedlichkeit auch im Ergebnis zeigen. Du hast diese Unterschiede gesucht und zielsicher aufgespürt - das ist ein gutes Zeichen!

Gruß,

Simon2.

...

A a=5;
    A b(5);
    // Nun wurde 2x der Zuweisungskonstruktor aufgerufen.
    // Ist dann also "=" und "(5)" für den  Compiler gleichbedeutend ???

Mit der Begrifflichkeit wäre ich vorsichtig, zumindest kenne ich den Begriff "Zuweisungskonstruktor" nicht. Ich kenne den Begriff Konstruktor, was im Obigen Fall bei der Initialisierung zutreffen wäre. Und ich kenne den Zuweisungsoperator der in diesem Fall die Notation A& operator=(A const &) hätte.

cu André