std::shared_ptr der abstrakten Klasse abgeleitete Klasse instanziieren

Ich versuche, mit std::shared_ptr, aber ich bin nicht sicher, ob ich benutzen kann shared_ptr für eine abstrakte Klasse, und rufen Sie eine abgeleitete Klasse von dieser smart-pointer. Hier ist der code, den ich derzeit

IExecute *ppCIExecuteExecuteOperation = NULL;

for(int i = 0; i < 3; ++i)
{
    switch (stOperationType.key)
    {
        case E_OPERATIONKEY::DrawCircle:
        pCIExecuteExecuteOperation = new CCircle();
        break;
        case E_OPERATIONKEY::DrawSquare:
        pCIExecuteExecuteOperation = new CSquare();
        break;
        case E_OPERATIONKEY::Rhombus:
        pCIExecuteExecuteOperation = new CRehombus();
        break;
        default:
        break;
    }
} 
pCIExecuteExecuteOperation->Draw();

Hier IExecute ist eine abstrakte Klasse und CCircle, CSquare, CRhombus ist eine abgeleitete Klasse von IExecute.

Alles was ich will zu tun ist, verwenden Sie shared_ptr<IEXectue>pCIExecuteExecuteOperation(nullptr)
und innerhalb einer switch-Anweisung machen Sie zu einer der abgeleiteten Klasse, Wie kann ich das erreichen?

Bearbeiten:
Die Antworten waren zu verwenden make_shared oder reset()

Danke Jungs, ich dint erwarten, dass es so einfach sein.

Haben Sie tatsächlich versucht, es zu tun?
Die offensichtliche Art und Weise funktionieren sollte.
ich bin neu in c++ shared_ptr, lief über paar Seiten und war verwirrt

InformationsquelleAutor Barry | 2014-08-20

c++c++11 inheritance smart-pointers

6

Ist das einfach. Blick auf code und fühlen.
```
std::shared_ptr<IExecute> ppCIExecuteExecuteOperation;

for(int i = 0; i < 3; ++i)
{
    switch (stOperationType.key)
    {
        case E_OPERATIONKEY::DrawCircle:
            pCIExecuteExecuteOperation.reset(new CCircle());
            break;
        case E_OPERATIONKEY::DrawSquare:
            pCIExecuteExecuteOperation.reset(new CSquare());
            break;
        case E_OPERATIONKEY::Rhombus:
            pCIExecuteExecuteOperation.reset(new CRehombus());
            break;
        default:
            break;
    }
} 
pCIExecuteExecuteOperation->Draw();
```
- Ist es nicht sicherer in Bezug auf Speicherlecks zu verwenden std::make_shared statt new?
- warum? könnten Sie mir erklären?
- Die Hinweise auf cppreference dies zu zeigen. Nun, die Frage ist, ob dieser code ist auch gute Praxis, weil es schwer ist zu Lesen, ohne make_shared, aber es kann zu Problemen führen.
- Nein, das ist okay, um direkt new in diesem Fall. Der Punkt, dass cppref Seite beziehen sich auf Reihenfolge der Auswertung, aber in meinem Fall nicht auftreten.
- Danke Jungs, aber ich will wissen, was ist der Unterschied in der Verwendung von std::make_shared und "neu", wie im obigen code
- In diesem Fall nicht, weil du reset verwenden, anstatt den Bau einer neuen shared_ptr durch Aufruf von std::shared Konstruktor. Ich habe nie gesehen, dass die Verwendung von reset(). Gibt es einen Grund, lieber reset()? Meiner Meinung nach ein Aufruf an make_shared oder den ctor von shared_ptr kombiniert mit der Zuweisungsoperator ist besser zu Lesen.
- Ich bevorzuge die make_shared Ansatz, weil es verbessert die Lesbarkeit. Auch Nähte zu mir, dass es ist die am häufigsten verwendete Ansatz, trotz vielleicht der shared_ptr<T>(newT()) Ansatz kann zu einem Speicherverlust führen, wie in einem früheren post erwähnt. Ich habe tatsächlich einige Bücher und Artikel gelesen über shared_ptr, aber es ist das erste mal, dass ich die Verwendung von reset für die Zuweisung einer shared_ptr. Wenn ich ehrlich bin, habe ich nicht neues von reset vor und sah ihn von oben bis.
- Beide Ansätze verwiesen werden, die auf cppreference und cplusplus als eine Methode zu erwerben, ownerwhip eines Objekts, also seine wahrscheinlich nur eine Präferenz-Sache.
- Danke @evotion für die ausführliche Beschreibung..
- Ich benutze reset denn es macht den code besser kürzer und einfach.
InformationsquelleAutor ikh
2

Die Methode std::make_shared<T> erzeugt ein shared-pointer-Objekt vom Typ T auf und ruft deren Konstruktor. Also, anstatt zu telefonieren new nennen std::make_shared.
```
std::shared_ptr<IEXectue>pCIExecuteExecuteOperation(nullptr);
...
...
switch (stOperationType.key)
{
    case E_OPERATIONKEY::DrawCircle:
    pCIExecuteExecuteOperation = std::make_shared<CCircle>();
    break;
    ...
```
std::make_shared ist auch in der Lage, verwenden Parameter, die an den Konstruktor übergeben wird, vorausgesetzt, es ist ein construcotr mit, dass die Parameter-Liste.

InformationsquelleAutor evotion
1

Die Linie
```
IExecute *ppCIExecuteExecuteOperation = NULL;
```
sein sollte, ersetzen Sie mit
```
std::shared_ptr<IExecute> pExecute;
```
und dann jeweils die Zeilen mit den Zuweisungen geschrieben werden kann als
```
pExecute.reset(new CCircle);
```
Dann können Sie anrufen Draw
```
pExecute->Draw();
```
- Danke, es wurde im detail erläutert und Ihre Arbeitsweise
- href="http://stackoverflow.com/help/someone-answers">stackoverflow.com/help/someone-answers
- Ich kann nicht abstimmen, ich habe nicht genug Ruf zu Stimmen..
- Aber ich habe die Antworten hat Ihnen geholfen, sollten Sie akzeptieren, dass man von Ihnen
InformationsquelleAutor Wojtek Surowka

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.