Im Falle

CString cs1 = cs2;

wird der Konstruktor CString::CString(CString&) aufgerufen, währen im Falle

CString cs1;
cs1 = cs2;

der Operator "=" aufgerufen wird.

http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=copyvsdirect#Answ

mfg.

CString cs = "hallo";
CString cs; cs = "Hallo";

während folgendes identisch ist:

CString cs = "hallo";
CString cs( "hallo" );

#include <iostream>

struct CString
{
    CString() { std::cout << "1\n"; }
    CString(const CString&) { std::cout << "2\n"; }
    CString& operator=(const CString&) { std::cout << "3\n"; }
};

int main()
{
    CString cs2;
    std::cout << "-\n";
    CString cs1;
    cs1 = cs2;
    std::cout << "-\n" << std::flush;
    CString cs3 = cs2;
}

1
-
1
3
-
2

mfg.

CString cs2 = CString::IntToHex(i, 8);

folgendes aber nicht:

CString cs2( CString::IntToHex(i, 8) );

Da sagt er mir: "[C++Fehler] Project1.cpp(149): Could not find a match for 'CString::CString(CString)'."

Funktioniert einwandfrei. Nutzt Du zufällig VC++6?

EDIT:
Funzt selbst mit dem. Welche Signatur hat denn CString::IntToHex?

class CString
{
private:
    LPTSTR m_String;
    unsigned int m_BufSize;

    void MakeNew(unsigned int size);

public:
    // Konstruktoren
    CString(LPTSTR str);
    CString(LPCTSTR str);
    CString(CString& str);
    CString(int length);
    CString();

    // Destruktor
    ~CString();

    // Hauptmethoden
    int Length();
    bool Delete(unsigned int index, unsigned int count); // index is zero based
    void Insert(CString& str, unsigned int index); // index is zero based
    void UpperCase();
    void LowerCase();
    int LoadString(HINSTANCE hInstance, UINT uiID);
    int Compare(CString& rhs, bool case_sensitive);
    CString SubString(unsigned int index, unsigned int count); // index is zero based
    int ToInt(); // Encapsulates atoi(), i.e. ToInt() == 0 if m_String is no integer value
    double ToDouble();          // Trennzeichen ist der Punkt (.)
    long double ToLongDouble(); //  -"-
    LPWSTR ToWideChar(LPWSTR dest, int destSize);
    LPSTR ToMultiByte(LPSTR dest, int destSize);
    int FirstPositionOf(CString& subStr);
    int LastPositionOf(CString& subStr);
    LPTSTR c_str();
    bool IsEmpty();
    int GetWindowText(HWND hwnd);
    int SetWindowText(HWND hwnd);

    // Statics
    static CString IntToHex(unsigned int value, unsigned int digits);

    // Operatoren
    void operator =(CString& rhs);
    void operator =(LPTSTR str);
    void operator =(LPCTSTR str);
    bool operator ==(CString& rhs) const;
    bool operator ==(LPTSTR str) const;
    bool operator ==(LPCTSTR str) const;
    CString operator +(CString& rhs) const;
    CString operator +(LPTSTR str) const;
    void operator +=(CString& rhs);
    TCHAR operator [](int index); // index is zero based
};

CString(const CString& str);

Wobei der VC++6 das sogar durchgehen lässt

CString::CString(const CString& str)
{
   m_BufSize = str.Length() + 1;
   m_String = (LPTSTR)new TCHAR[m_BufSize];
   lstrcpy(m_String, str.c_str());
}

die folgenden Warnungen:

[C++Warnung] CString.cpp(53): Non-const function CString::Length() called for const object.
[C++Warnung] CString.cpp(55): Non-const function CString::c_str() called for const object.

Die Methode Length (z.B.) ist nicht const markiert, daher weiss der Compiler nicht, dass die Methode Length keine Änderungen an dem Objekt vornimmt. Du kannst auf einem konstanten Objekt nur Konstante Methoden aufrufen.

Also Möglichkeit 1:

CString::CString(const CString& str)
{
   m_BufSize = strlen(str.m_String) + 1;
   m_String = (LPTSTR)new TCHAR[m_BufSize];
   lstrcpy(m_String, str.m_String);
}

Und Möglichkeit 2:

int Length() const;

Wobei Möglichkeit 2 generell immer genutzt werden sollte, wenn die Methode das Objekt tatsächlich nicht ändert. (Gutes Suche- oder Google-Stichwort: const-correctness)

Alles klar:
Der Kopierkonstruktor muss eine konstante Referenz auf CString annehmen, keine normale, da Du hier ein temporäres Objekt erzeugst (nämlich das Ergebnis von IntToHex, welches solange lebt bis der Konstruktor durchgelaufen ist). Dein "Copy-Constructor" ist strenggenommen nämlich garkeiner, sondern nur ein Non-Default-Constructor.

CString(const CString& str);

Wobei der VC++6 das sogar durchgehen lässt

das ist schon ein copy-konstruktor. der standard erlaubt 4 verschiedene signaturen, die einen copy-konstruktor darstellen entsprechend den 4 möglichkeiten für cv-qualifikation (wobei die mit volatile niemals implizit deklariert werden). das wird zum beispiel bei std::auto_ptr genutzt (wohlgemerkt: die template-konstruktoren sind - selbst mit geeignetem templateparameter - keine copy-kosntruktoren).

Aber der Grund warum dieser CCtor trotzdem nicht gegriffen hat ist ja geklärt

Aber der Grund warum dieser CCtor trotzdem nicht gegriffen hat ist ja geklärt

Echt? Sry ich hab's noch nicht verstanden, wo war denn das Problem?

mfg.

CString s( CString::IntToHex(...) );

Nur mit einem const CString& Ctor funktionieren. Wie von camper im anderen Thread zu dem Thema angesprochen, funktioniert hier eine Zuweisung, weil der Compiler daraus keine Initialisierung machen muss.

CString s = CString::IntToHex(...);
// ist hier also wirklich identisch zu
CString s; s = CString::IntToHex(...);
// weil keine geeignete Initialisierung verfügbar ist

// CString.h
int Length() const;

// CString.cpp
int CString::Length() const
{
   return lstrlen(m_String);
}

Kommt mir etwas komisch vor mit dem const am Ende.

CString s = CString::IntToHex(...);
// ist hier also wirklich identisch zu
CString s; s = CString::IntToHex(...);
// weil keine geeignete Initialisierung verfügbar ist

nein. die erste variante ist immer eine initialisierung und benötigt einen geeigneten (und zugreifbaren) copy-konstruktor, selbst wenn dieser ctor-aufruf vom compiler eliminiert wird (das kreiden in letzterem falle nicht alle compiler an, also ggf. dem compiler geeignete switches für maximale konformität mitgeben). andere compiler haben diese furchtbare erweiterung, die ein binden von (non-const) rvalues an referenzen auf nicht-const erlauben. [anm.: erste zeile könnte noch andere konstruktoren involvieren, ein copy-ctor ist aber auf jeden fall erforderlich]

die zweite zeile ist immer eine zuweisung. das muss nicht zwingend copy-zuweisung sein, falls ein geeigneter konvertierungspfad existiert, könnte hier auch ein anders überladener operator= aufgerufen werden.

Hö? Ich verstehe kein Wort. War das jetzt eine Antwort auf meine letzte Frage?

nein, das war nicht die antwort auf deine frage. die wäre mit ja zu beantworten.

Das mit dem Konstruktor hatten wir doch mittlerweile geklärt, oder?

offenbar noch nicht ganz.