C++, wat betekent de dubbele punt na een constructor?

Mogelijke duplicaten:
Variabelen na de dubbele punt in een constructor
C++ constructorsyntaxisvraag (noob)

Ik heb hier wat C++-code:

class demo 
{
private:
    unsigned char len, *dat;
public:
    demo(unsigned char le = 5, unsigned char default) : len(le) 
    { 
        dat = new char[len];                                      
        for (int i = 0; i <= le; i++)                             
            dat[i] = default;
    }
    void ~demo(void) 
    {                                            
        delete [] *dat;                                           
    }
};
class newdemo : public demo 
{
private:
    int *dat1;
public:
    newdemo(void) : demo(0, 0)
    {
     *dat1 = 0;                                                   
     return 0;                                                    
    }
};

Mijn vraag is, hoe worden de : len(le)en : demo(0, 0)genoemd?

Heeft het iets met erfenis te maken?

Antwoord 1, autoriteit 100%

Zoals anderen al hebben gezegd, is het een initialisatielijst. Je kunt het voor twee dingen gebruiken:

1. Configuratoren van basisklassen aanroepen
2. Initialiseren van lidvariabelen voordat de hoofdtekst van de constructor wordt uitgevoerd.

Voor geval #1 neem ik aan dat je de erfenis begrijpt (als dat niet het geval is, laat het me dan weten in de comments). Dus je roept gewoon de constructor van je basisklasse aan.

Voor geval #2 kan de vraag worden gesteld: “Waarom initialiseer je het niet gewoon in de body van de constructor?” Het belang van de initialisatielijsten is vooral duidelijk voor const-leden. Kijk bijvoorbeeld eens naar deze situatie, waarin ik m_valwil initialiseren op basis van de constructorparameter:

class Demo
{
    Demo(int& val) 
     {
         m_val = val;
     }
private:
    const int& m_val;
};

Volgens de C++-specificatie is dit illegaal. We kunnen de waarde van een variabele constin de constructor niet wijzigen, omdat deze is gemarkeerd als const. U kunt dus de initialisatielijst gebruiken:

class Demo
{
    Demo(int& val) : m_val(val)
     {
     }
private:
    const int& m_val;
};

Dat is de enige keer dat u een const-lidvariabele kunt wijzigen. En zoals Michael opmerkte in het opmerkingengedeelte, is het ook de enige manier om een referentie te initialiseren die een klaslid is.

Behalve het gebruik om const-lidvariabelen te initialiseren, lijkt het algemeen aanvaard te zijn als “de manier” om variabelen te initialiseren, dus het is duidelijk voor andere programmeurs die uw code lezen.

Antwoord 2, autoriteit 11%

Dit wordt een initialisatielijst genoemd. Het is voor het doorgeven van argumenten aan de constructor van een bovenliggende klasse. Hier is een goede link die het uitlegt: Initialisatielijsten in C++

Antwoord 3, autoriteit 2%

Dit wordt een initialisatielijst genoemd. Een initialisatielijst is hoe u argumenten doorgeeft aan de constructors van uw lidvariabelen en voor het doorgeven van argumenten aan de constructor van de bovenliggende klasse.

Als u =gebruikt om in de constructor-instantie toe te wijzen, wordt eerst de standaardconstructeur gebeld, dan wordt de toewijzingsoperator genoemd. Dit is een beetje verspilling, en soms is er geen equivalente toewijzingsoperator.

Antwoord 4

Het wordt een initialisatielijst genoemd. Het initialiseert de leden voordat het lichaam van de constructor wordt uitgevoerd.

Antwoord 5

Dit betekent dat lenniet is ingesteld met behulp van de standaardconstructeur. Terwijl de demoklasse wordt geconstrueerd. Bijvoorbeeld:

class Demo{
    int foo;
public:
    Demo(){ foo = 1;}
};

zou eerst een waarde in Foo plaatsen voordat u het instelt naar 1. Het is iets sneller en efficiënter.

Antwoord 6

U belt de constructeur van de basisklasse, demo.