Een instantie van klasse maken

Wat is het verschil tussen regels 1 , 2 , 3 , 4?

Wanneer gebruik ik ze allemaal?

Waarom drukt regel 3 de constructor Fooaf en geeft regel 7 een fout en regel 8 niet?

#include <iostream>     
using namespace std;
class Foo
 {
   public:
   Foo ( )
   {
      cout << "constructor Foo\n";
   }               
};
class Bar
 {
   public:
   Bar ( Foo )
   {
      cout << "constructor Bar\n";
   }
};
int main()
{
   /* 1 */ Foo* foo1 = new Foo ();
   /* 2 */ Foo* foo2 = new Foo;
   /* 3 */ Foo foo3;
   /* 4 */ Foo foo4 = Foo::Foo();
   /* 5 */ Bar* bar1 = new Bar ( *new Foo() );
   /* 6 */ Bar* bar2 = new Bar ( *new Foo );
   /* 7 */ Bar* bar3 = new Bar ( Foo foo5 );
   /* 8 */ Bar* bar3 = new Bar ( Foo::Foo() );
   return 1;
}

Antwoord 1, autoriteit 100%

  /* 1 */ Foo* foo1 = new Foo ();

Maakt een object van het type Fooin dynamisch geheugen. foo1verwijst ernaar. Normaal gesproken zou u in C++ geen onbewerkte aanwijzers gebruiken, maar eerder een slimme aanwijzer. Als Fooeen POD-type was, zou dit waarde-initialisatie uitvoeren (dit is hier niet van toepassing).

  /* 2 */ Foo* foo2 = new Foo;

Identiek aan vroeger, omdat Foogeen POD-type is.

  /* 3 */ Foo foo3;

Maakt een Foo-object met de naam foo3in automatische opslag.

  /* 4 */ Foo foo4 = Foo::Foo();

Gebruikt kopieerinitialisatie om een Foo-object met de naam foo4te maken in automatische opslag.

  /* 5 */ Bar* bar1 = new Bar ( *new Foo() );

Gebruikt de conversie-constructor van Barom een object van het type Barte maken in dynamische opslag. bar1is een verwijzing ernaar.

  /* 6 */ Bar* bar2 = new Bar ( *new Foo );

Hetzelfde als voorheen.

  /* 7 */ Bar* bar3 = new Bar ( Foo foo5 );

Dit is gewoon een ongeldige syntaxis. Je kunt daar geen variabele declareren.

  /* 8 */ Bar* bar3 = new Bar ( Foo::Foo() );

Zou werken en werken volgens hetzelfde principe als 5 en 6 als bar3niet was gedeclareerd in 7.

5 & 6bevatten geheugenlekken.

Syntaxis zoals new Bar ( Foo::Foo() );is niet gebruikelijk. Het is meestal new Bar ( (Foo()) );– extra haakjesaccount voor meest irritante parse.(gecorrigeerd)

Antwoord 2, autoriteit 16%

1. Wijst wat dynamisch geheugen toe uit de gratis opslag en maakt een object in dat geheugen met behulp van de standaardconstructor. Je verwijdert het nooit, dus het geheugen is gelekt.
2. Doet precies hetzelfde als 1; in het geval van door de gebruiker gedefinieerde typen zijn de haakjes optioneel.
3. Wijst automatisch geheugen toe en maakt een object in dat geheugen met behulp van de standaardconstructor. Het geheugen wordt automatisch vrijgegeven wanneer het object buiten bereik gaat.
4. Vergelijkbaar met 3. Het benoemde object foo4wordt standaard geïnitialiseerd door een tijdelijk object te construeren, te kopiëren en te vernietigen; meestal wordt dit weggelaten, wat hetzelfde resultaat geeft als 3.
5. Wijst een dynamisch object toe en initialiseert vervolgens een tweede door het eerste te kopiëren. Beide objecten zijn gelekt; en er is geen manier om de eerste te verwijderen omdat je er geen verwijzing naar bewaart.
6. Doet precies hetzelfde als 5.
7. Compileert niet. Foo foo5is een verklaring, geen uitdrukking; functie (en constructor) argumenten moeten uitdrukkingen zijn.
8. Maakt een tijdelijk object en initialiseert een dynamisch object door het te kopiëren. Alleen het dynamische object is gelekt; de tijdelijke wordt automatisch vernietigd aan het einde van de volledige expressie. Merk op dat je de tijdelijke kunt maken met alleen Foo()in plaats van de equivalente Foo::Foo()(of inderdaad Foo::Foo::Foo::Foo::Foo())

Wanneer gebruik ik ze allemaal?

1. Niet doen, tenzij je van onnodige versieringen op je code houdt.
2. Als u een object wilt maken dat langer meegaat dan het huidige bereik. Vergeet niet om het te verwijderen als je ermee klaar bent, en leer hoe je slimme aanwijzersgebruikt om de levensduur gemakkelijker te beheren.
3. Als u een object wilt dat alleen in het huidige bereik bestaat.
4. Niet doen, tenzij je denkt dat 3 er saai uitziet en wat onnodige decoratie toe te voegen.
5. Niet doen, omdat het geheugen lekt zonder kans op herstel.
6. Niet doen, omdat het geheugen lekt zonder kans op herstel.
7. Niet doen, want het compileert niet
8. Als je een dynamische Barwilt maken van een tijdelijke Foo.

Antwoord 3, autoriteit 4%

Lijnen 1,2,3,4 belt de standaardconstructeur. Ze zijn in essentie verschillend als 1,2 zijn dynamisch gemaakt object en 3,4 zijn statisch gemaakte objecten.

In regel 7 maakt u een object in het argumentgesprek. Dus het is een fout.

en lijnen 5 en 6 zijn uitnodiging voor geheugenlek.