Wie vermeidet man Speicherzuweisung durch Verwendung von Referenz?

Question

#include <iostream> 
#include <string> 

struct A { 
    A(std::string s) { name = s; } 

    std::string name; 
}; 

struct B { 
    B(std::string s) : a(A(s)) {} 

    A& a; 
}; 

int main() { 
    B b("tom"); 

    std::cout << b.a.name << std::endl; 
} 

Ich versuche class B 's A & ein mit A's object zu vergeben. Ein paar Möglichkeiten, wie ich das machen könnte.

1) Machen Sie A & a zu A * a und machen Sie a = neue A (s) in B's Konstruktor. Das funktioniert, aber ich versuche das zu vermeiden, da ich neu machen und löschen muss.

2) Oben habe ich class B, die Zeichenfolge und erstellt ein Rvalue-Objekt, um lvalue Verweis zu initialisieren. Dies wird einen Kompilierungsfehler ergeben.

3) Ich kann A& a zu A&& a machen, aber nicht sicher, ob das gut ist. Da kompiliert es aber cout gibt Müll.

4) Erstellen Sie eine Instanz von A in main und übergeben Sie sie an Bs Konstruktor. Aber ich versuche das jetzt zu vermeiden.

Answer 1

Sie benötigen keine Referenzen, Zeiger oder ähnliches.

Sie brauchen nur ein Objekt vom Typ A, einfach so.

Plus können Sie alle Kopien vermeiden, indem Sie bewegen Semantik:

#include <iostream> 
#include <string> 
#include <utility> 

struct A 
{ 
    A(std::string s) : name(std::move(s)) {} 

    std::string name; 
}; 

struct B 
{ 
    B(std::string s) : a(std::move(s)) {} 

    A a; 
}; 

int main() 
{ 
    B b("tom"); 

    std::cout << b.a.name << std::endl; 
} 

Answer 2

Richtige und guten Code würde wie folgt aussehen:

struct A 
{ 
    A(std::string name) : name_(std::move(name)) {} 

    std::string name_; 
}; 

struct B 
{ 
    B(std::string name) : a_(std::move(name)) {} 

    A a_; 
};