Konstruktor kopiujący na argumencie przekazanym przez wartość

0

Konstruktor kopiujący na argumencie przysłanym przez referencję rozumiem. Jednak nie mogę zrozumieć co by było gdyby argument był przesyłany przez wartość. Wiem, że się tak nie robi. Bo w symfonii jest to tak opisane, że w konstruktorze kopiujący by musiał być uruchamiany kolejny konstruktor kopiujący. Jednak tego nie rozumiem. Mógłby ktoś pokazać przykład ?

I jeszcze jedno pytanie, jeśli je taka funkcja:

kalibracja druga(void)
{
kalibracja wewn(2,1,"Wewnetrzna");
return wewn;
}

To przy instrukcji zwracania tworzy się obiekt chwilowy, więc zostaje użyty konstruktor kopiujący ? Czy w przypadku takiej funkcji:

int funkcja(void)
{
int a = 4;
return a;
}

też przy zwracaniu tworzy się chwilowa zmienna ?

0

Gdyby argument był przesyłany przez wartość tworzyłaby się niepotrzebnie wersja tymczasowa argumentu, co niepotrzebnie zużywałoby pamięć i dodatkowo wywoływałoby konstruktor kopiujący, a więc w przypadku tego samego typu doszłoby do zapętlenia.

0

Mógłbyś podać przykład? Nie moge tego zrozumieć. Jak z tym 2 pytaniem?

0
#include <iostream>
#include <string>

using namespace std;

class Foo {
public:
    Foo();                      // Default constructor
    Foo(const Foo& foo);        // Copy constructor
    Foo(const string& name_);   // Argument constructor
    // Illegal!!!
    // Foo(Foo foo);
    Foo& operator=(const Foo& foo); // Assigned operator
    Foo getMyClone();
    ~Foo();                     // Destructor
private:
    string name;
};

Foo::Foo() : name("EMPTY") {
    cout << "|Foo " << name << " constructor." << endl;
}

Foo::Foo(const Foo& foo) {
    cout << "|Foo " << name << " const copy constructor." << endl;
}

Foo::Foo(const string& name_) : name(name_) {
    cout << "|Foo " << name << " constructor." << endl;
}

// Illegal !!!
//Foo::Foo(Foo foo) {
//    cout << "|Foo " << name << " illegal copy constructor" << ednl;
//}

Foo& Foo::operator=(const Foo& foo) {
    cout << "|In Foo " << name << " assigned operator." << endl;
    name = foo.name;
    cout << "|Foo " << name << " after assign." << endl;
    return *this;
}

Foo Foo::getMyClone() {
    string clone_name = name + " CLONE";
    Foo clone = Foo(clone_name);
    return clone;
}

Foo::~Foo() {
    cout << "|Foo " << name << " destructor." << endl;
}

int main(void) {
    cout << "* Foo construction with argument." << endl;
    Foo foo = Foo("first");
    cout << "* Foo default construction." << endl;
    Foo bar;
    cout << "* Foo assign." << endl;
    bar = foo;
    cout << "* Get clone foo." << endl;
    bar = foo.getMyClone();

    cout << "End program." << endl;
}

Wynik:

* Foo construction with argument.
|Foo first constructor.
* Foo default construction.
|Foo EMPTY constructor.
* Foo assign.
|In Foo EMPTY assigned operator.
|Foo first after assign.
* Get clone foo.
|Foo first CLONE constructor.
|In Foo first assigned operator.
|Foo first CLONE after assign.
|Foo first CLONE destructor.
End program.
|Foo first CLONE destructor.
|Foo first destructor.

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0