Een klasse-object maken in c++

Eerst kom ik uit JAVA.

In Java maken we zo een klasseobject.

Example example=new Example();

De klasse Voorbeeld kan een constructor hebben of kan geen constructor hebben.

Ik kan hetzelfde in c++ zo gebruiken

Example* example=new Example();

Waar constructor verplicht is.

Van deze tutorial http://www.cplusplus.com/doc/tutorial/classes/

Ik heb begrepen dat we een object als dit kunnen maken.

Example example;

Waarvoor geen constructor nodig is.

Ik heb twee vragen.

1. Wat is het verschil tussen beide manieren om klassenobjecten te maken.

2. Als ik een object maak zoals Example example; hoe dat te gebruiken in een singleton-klasse.

zoals ik meestal zo doe.

Sample* Singleton::get_sample() {
    if (sample == NULL) {
        sample = new Sample();
    }
    return sample;
}

Help me alsjeblieft als ik het mis heb.

Antwoord 1, autoriteit 100%

Ik kan hetzelfde gebruiken in c++ zoals dit […] Waar constructor verplicht is. Uit deze tutorial heb ik begrepen dat we een object als dit kunnen maken […] Welke geen constructor nodig.

Dit is fout. Een constructor moet bestaan om een ​​object te maken. De constructor zou onder bepaalde voorwaarden impliciet kunnen worden gedefinieerd door de compiler als je er geen geeft, maar uiteindelijk moet de constructor aanwezig zijn als je wilt dat een object wordt geïnstantieerd. In feite is de levensduur van een object gedefinieerd om te beginnen wanneer de constructorroutine terugkeert.

Uit paragraaf 3.8/1 van de C++11-standaard:

[…] De levensduur van een object van het type T begint wanneer:

opslag met de juiste uitlijning en grootte voor type T wordt verkregen, en

als het object een niet-triviale initialisatie heeft, is de initialisatie voltooid.

Daarom moet er een constructor aanwezig zijn.

1) Wat is het verschil tussen beide manieren om klassenobjecten te maken.

Wanneer u een object met automatische opslagduur instantiseert, zoals dit (waarbij x een klasse is):

X x;

U maakt een object dat automatisch wordt vernietigd wanneer het buiten bereik gaat. Aan de andere kant, wanneer u dit doet:

X* x = new X();

U maakt dynamisch een object en u koppelt het adres aan een aanwijzer. Op deze manier wordt het object dat je hebt gemaakt niet vernietigd wanneer je x-aanwijzer buiten bereik raakt.

In Modern C++ wordt dit beschouwd als een twijfelachtige programmeerpraktijk: hoewel pointers belangrijk zijn omdat ze het realiseren van referentie-semantiek, onbewerkte pointers zijn slecht omdat ze kunnen leiden tot geheugenlekken (objecten die al hun pointers overleven en nooit worden vernietigd) of in bungelende wijzers (wijzers die langer leven dan het object waarnaar ze verwijzen, en mogelijk ongedefinieerd gedrag veroorzaken wanneer ze worden verwijderd).

Als je een object maakt met new, moet je altijd onthouden dat je het hebt vernietigd met delete:

delete x;

Als je referentiesemantiek nodig hebt en genoodzaakt bent om pointers te gebruiken, zou je in C++11 moeten overwegen om slimme pointers te gebruiken:

std::shared_ptr<X> x = std::make_shared<X>();

Slimme aanwijzers lossen problemen met geheugenbeheer op, wat u hoofdpijn bezorgt met onbewerkte aanwijzers. Slimme aanwijzers zijn in feite bijna hetzelfde als Java- of C#-objectreferenties. De “bijna” is nodig omdat de programmeur ervoor moet zorgen dat er geen cyclische afhankelijkheden worden geïntroduceerd door slimme aanwijzers te bezitten.

2) Als ik een object aan het maken ben, zoals Voorbeeld; hoe je dat in een eenlingklas kunt gebruiken.

Je zou zoiets als dit kunnen doen (vereenvoudigde code):

struct Example
{
    static Example& instance()
    {
        static Example example;
        return example;
    }
 private:
    Example() { }
    Example(Example const&) = delete;
    Example(Example&&) = delete;
    Example& operator = (Example const&) = delete;
    Example& operator = (Example&&) = delete;
};

Antwoord 2, autoriteit 64%

Example example;

Dit is een declaratie van een variabele met de naam example van het type example. Hiermee wordt het object standaard geïnitialiseerd, waarbij de standaardconstructor wordt aangeroepen. Het object heeft een automatische opslagduur, wat betekent dat het wordt vernietigd wanneer het buiten bereik gaat.

Example* example;

Dit is een declaratie van een variabele met de naam example die een pointer is naar een example. In dit geval laat de standaardinitialisatie het niet geïnitialiseerd – de aanwijzer wijst nergens in het bijzonder. Er is hier geen example-object. Het aanwijzerobject heeft een automatische opslagduur.

Example* example = new Example();

Dit is een declaratie van een variabele met de naam example die een pointer is naar een example. Dit aanwijzerobject heeft, zoals hierboven, een automatische opslagduur. Het wordt dan geïnitialiseerd met het resultaat van new Example();. Deze new-expressie maakt een example-object met dynamische opslagduur en retourneert er vervolgens een aanwijzer naar. Dus de example-aanwijzer wijst nu naar dat dynamisch toegewezen object. Het example-object is een waarde-geïnitialiseerde die een door de gebruiker verstrekte constructor aanroept als die er is of anders alle leden op 0 initialiseert.

Example* example = new Example;

Dit is vergelijkbaar met de vorige regel. Het verschil is dat het example-object standaard geïnitialiseerd is, waardoor de standaardconstructor van example wordt aangeroepen (of het niet-geïnitialiseerd laat als het niet van het klassetype is).

Een dynamisch toegewezen object moet deleted zijn (waarschijnlijk met delete example;).

Antwoord 3, autoriteit 14%

Er zijn twee manieren om een ​​object te maken/maken in c++.

Eerste is:

MyClass myclass; // if you don;t need to call rather than default constructor    
MyClass myclass(12); // if you need to call constructor with parameters

Tweede is:

MyClass *myclass = new MyClass();// if you don;t need to call rather than default constructor
MyClass *myclass = new MyClass(12);// if you need to call constructor with parameters

Als u in c++ een nieuw trefwoord gebruikt, wordt het object in de heap opgeslagen. het is erg handig als u dit object voor een lange periode gebruikt en als u de eerste methode gebruikt, wordt het in de stapel opgeslagen. het kan slechts korte tijdsperiode worden gebruikt. Let op: als u een nieuw trefwoord gebruikt, onthoud dan dat het de pointerwaarde zal retourneren. je moet naam aangeven met *. Als u de tweede methode gebruikt, wordt het object in de heap niet verwijderd. u moet zelf verwijderen met behulp van het verwijdersleutelwoord;

delete myclass;

Antwoord 4, autoriteit 6%

1) Wat is het verschil tussen beide manieren om klassenobjecten te maken.

a) aanwijzer

Example* example=new Example();
// you get a pointer, and when you finish it use, you have to delete it:
delete example;

b) Eenvoudige aangifte

Example example;

je krijgt een variabele, geen pointer, en deze wordt vernietigd buiten het bereik dat hij is gedeclareerd.

2) Singleton C++

Deze SO-vraag kan je misschien helpen

Antwoord 5, autoriteit 6%

Allereerst wordt in beide gevallen een constructor aangeroepen. Als je schrijft

Example *example = new Example();

daarna maak je een object, roep je de constructor aan en haal je een verwijzing ernaar op.

Als je schrijft

Example example;

Het enige verschil is dat je het object krijgt en geen een verwijzing ernaar. De constructor die in dit geval wordt aangeroepen is dezelfde als hierboven, de standaard (geen argument) constructor.

Wat betreft de singleton-vraag, je moet eenvoudig je statische methode aanroepen door te schrijven:

Example *e = Singleton::getExample();

Antwoord 6, autoriteit 6%

1)Wat is het verschil tussen beide manieren om klasse te creëren?
objecten.

De eerste is een verwijzing naar een geconstrueerd object in de heap (door new).
De tweede is een object dat impliciet is geconstrueerd. (Standaardconstructor)

2)Als ik een object aan het maken ben, zoals Voorbeeld; hoe dat te gebruiken in een
singleton klasse.

Het hangt af van je doelen, het makkelijkst is om het gewoon als lid in de klas te zetten.

Een voorbeeld van een singleton-klasse met een object uit de example-klasse:

class Sample
{
    Example example;
public:
    static inline Sample *getInstance()
    {
        if (!uniqeInstance)
        {
            uniqeInstance = new Sample;
        }
        return uniqeInstance;
    }
private:
    Sample();
    virtual ~Sample();
    Sample(const Sample&);
    Sample &operator=(const Sample &);
    static Sample *uniqeInstance;
};

Antwoord 7, autoriteit 4%

Example example;

Dit voorbeeld is een object op de stapel.

Example* example=new Example();

Hier kan worden ingebroken in:

Example* example;
....
example=new Example();

Hier creëert de eerste instructie een variabel voorbeeld dat een “pointer naar Voorbeeld” is. Wanneer de constructor wordt aangeroepen, wordt er geheugen voor toegewezen op de heap (dynamische toewijzing). Het is de verantwoordelijkheid van de programmeur om dit geheugen vrij te maken wanneer het niet langer nodig is. (C++ heeft geen garbage collection zoals java).

Antwoord 8, autoriteit 4%

In het eerste geval maakt u het object op de heap met behulp van new.
In het tweede geval maakt u het object op de stack, dus het wordt verwijderd wanneer het buiten bereik gaat.
In C++ moet je objecten op de heapexpliciet verwijderen met delete wanneer je ze niet meer nodig hebt.

Als je een statische methode uit een klasse wilt aanroepen, doe je

Singleton* singleton = Singleton::get_sample();

in je hoofdfunctie of waar dan ook.