Wirtualny konstruktor C++

Wirtualny Konstruktor C



C++ nie ułatwia nam konstruowania wirtualnych konstruktorów, ponieważ nie ma możliwości przesłonięcia konstruktora klasy. Zatem wirtualizacja konstruktorów jest bez znaczenia. Nie ma koncepcji tworzenia wirtualnego konstruktora w programie C++, ale możemy tam stworzyć wirtualny destruktor. Możemy to również zdefiniować, ponieważ programowania konstruktora w C++ nie można uznać za wirtualne, ponieważ po wywołaniu konstruktora klasy w pamięci nie ma wirtualnej tabeli, co oznacza, że ​​nie jest tworzony żaden wirtualny wskaźnik. Dlatego konstruktor powinien być zawsze niewirtualny.

Może jednak istnieć wirtualny destruktor. Tutaj pokażemy, co się stanie, gdy utworzymy wirtualny konstruktor w C++, a także działanie wirtualnego destruktora zamiast wirtualnego konstruktora.

Przykład 1:

Stwórzmy wirtualny konstruktor i rozpocznijmy nasz kod od umieszczenia pliku nagłówkowego „iostream”. Ten plik nagłówkowy jest przeznaczony dla zadeklarowanych w nim funkcji, takich jak „cin” i „cout”. Następnie dodajemy przestrzeń nazw „std”, więc nie możemy dodać tej „std” do każdej funkcji w naszym kodzie. Następnie tworzymy klasę będącą klasą bazową naszego kodu o nazwie „my_base”, a następnie dodajemy „public”, aby utworzyć wirtualny konstruktor.







Wirtualny konstruktor tworzony jest tutaj poprzez umieszczenie słowa kluczowego „virtual”. Wewnątrz tego wirtualnego konstruktora umieszczamy instrukcję „cout”. Poniżej tworzymy funkcję o nazwie „show”, w której ponownie używamy „cout”. Następnie tworzymy klasę pochodną tej klasy bazowej o nazwie „my_derived”, a następnie ustanawiamy konstruktor „my_derived()” w polu „public”. Wstawiamy instrukcję „cout” do konstruktora „my_derived()”. Poniżej konstruujemy funkcję o nazwie „show”, w której ponownie korzystamy z „cout”.



Teraz po wywołaniu funkcji „main()” tworzymy wskaźnik klasy bazowej o nazwie „my_ptr” oraz tworzymy obiekt klasy pochodnej „Obj_d”. Następnie przypisujemy adres „Obj_d” do „my_ptr”. Następnie wywołujemy funkcję „show()” poprzez „my_ptr”.



Kod 1:





#include
za pomocą przestrzeń nazw st ;
klasa moja_baza
{
publiczny :
wirtualny moja_baza ( )
{
cout << „Oto moja klasa podstawowa” << koniec ;
}
próżnia pokazywać ( )
{
cout << „funkcja show klasy bazowej” << koniec ;
}
} ;
klasa moje_pochodne : publiczny moja_baza
{
publiczny :
moje_pochodne ( )
{
cout << „Oto moja klasa pochodna” << koniec ;
}
próżnia pokazywać ( )
{
cout << „funkcja pokazu klasy pochodnej” < pokazywać ( ) ;
}

Wyjście:
Tutaj pokazuje komunikat o błędzie, który mówi, że konstruktora nie można zadeklarować jako wirtualnego w programowaniu C++. Widzimy więc, że C++ nie pozwala nam wygenerować wirtualnego konstruktora, ale możemy stworzyć wirtualny destruktor.



Przykład 2:

Rozwiążmy poprzedni problem i utwórzmy wirtualny destruktor w tym kodzie. Po zadeklarowaniu klasy „new_base” umieszczamy konstruktor „public” w którym tworzymy wirtualny destruktor dodając „virtual ~” z „new_base”. Do tego wirtualnego destruktora wstawiamy instrukcję „cout”. Poniżej konstruujemy funkcję o nazwie „show”, która korzysta z „cout”. Następnie tworzymy klasę pochodną, ​​która jest „new_derived” tej klasy bazowej „new_base” i konstruujemy destruktor „new_derived()” w polu „public”. Do destruktora „new_derived()” dodano teraz instrukcję „cout”.

Poniżej tworzymy funkcję o nazwie „show”, która ponownie używa instrukcji „cout”. Po wywołaniu funkcji „main()” tworzymy teraz obiekt klasy pochodnej „obj_d” oraz wskaźnik klasy bazowej o nazwie „ptr1”. Następnie nadajemy adres „obj_d” adresowi „ptr1”. Następnie wywoływana jest metoda „show()” za pomocą „ptr1”.

Kod 2:

#include
za pomocą przestrzeń nazw st ;
klasa nowa_baza
{
publiczny :
wirtualny ~nowa_baza ( )
{
cout << „Destruktor klasy bazowej jest tutaj” << koniec ;
}
próżnia pokazywać ( )
{
cout << „Funkcja show klasy bazowej” << koniec ;
}
} ;
klasa nowe_pochodne : publiczny nowa_baza
{
publiczny :
~nowe_pochodne ( )
{
cout << „Destruktor klasy pochodnej jest tutaj” << koniec ;
}
próżnia pokazywać ( )
{
cout << „Funkcja show klasy bazowej” < pokazywać ( ) ;
}

Wyjście:
Program ten używa obiektu wskaźnikowego „new_base”, który wskazuje na klasę pochodną „obj_d”. Dlatego najpierw wywołuje metodę „show()” klasy „new_base”. Następnie wywołuje metodę „~new_derived()” klasy „new_derived” i wyświetla „~new_base” klasy bazowej.

Przykład 3:

Oto kolejny kod generujący „wirtualny” konstruktor. Po włączeniu przestrzeni nazw „iostream” i „std” generujemy klasę „B”. Poniżej tworzymy „publiczny” konstruktor, którym jest „B()”, a następnie generujemy „cout”. Funkcje konstruktora i destruktora są definiowane przy użyciu „publicznego” specyfikatora dostępu, z którego może korzystać dowolny obiekt w klasie.

Teraz tworzymy także destruktor „~B()” tej klasy bazowej, w którym ponownie wykorzystujemy „cout”. Następnie tworzymy klasę „D”, która jest klasą pochodną klasy bazowej „B” i umieszczamy tutaj „public”. Wewnątrz tej „publiczności” tworzymy konstruktor i destruktor klasy pochodnej o nazwach odpowiednio „D()” i „~D”. Obydwa zawierają w sobie słowo „cout”. Teraz mamy funkcję „main()”. Po wywołaniu tej funkcji generujemy obiekt wskaźnikowy klasy bazowej.

Następnie używamy słowa kluczowego „delete” i umieszczamy tutaj „base_ptr”. W tym przypadku przestrzeń destruktora jest usuwana poprzez wywołanie obiektu wskaźnikowego klasy bazowej.

Kod 3:

#include
za pomocą przestrzeń nazw st ;
klasa B
{
publiczny :
B ( )
{
cout << „Konstruktor klasy bazowej” << koniec ;
}
~B ( )
{
cout << „Destruktor klasy bazowej” << koniec ;
}
} ;

klasa D : publiczny B
{
publiczny :
D ( )
{
cout << „Konstruktor klasy pochodnej” << koniec ;
}
~D ( )
{
cout << „Destruktor klasy pochodnej” << koniec ;
}
} ;
wew główny ( )
{
B * podstawa_ptr = nowy D ;
usuwać podstawa_ptr ;
}

Wyjście:
Wynik pokazuje, że używa obiektu wskaźnikowego, który wskazuje klasę „B” w funkcji głównej. Dlatego najpierw wywołuje „konstruktor()” klasy „B”. Następnie wywołuje „konstruktor()” klasy „D”. Obiekt wskaźnikowy przechowywany przez destruktory klas „B” i „D” jest następnie usuwany. Bez wywoływania w programie destruktora klasy „D”, wskaźnik klasy „B” eliminuje jedynie destruktor klasy „B”. W rezultacie pamięć programu jest uszkodzona.

Wniosek

Omówiliśmy koncepcję „wirtualnej konstrukcji” w programowaniu w C++. Odkryliśmy, że nie możemy utworzyć wirtualnego konstruktora w C++, ale możemy stworzyć wirtualny destruktor w naszych kodach. Tutaj pokazaliśmy, co się dzieje, gdy tworzymy wirtualny konstruktor w programowaniu w C++ i jak działa wirtualny destruktor w naszych kodach. Dowiedzieliśmy się, że konstruktor nie może być wirtualny, ale możemy wygenerować wirtualny destruktor w naszej klasie. W tym przewodniku zademonstrowaliśmy kilka przykładów i dokładnie wyjaśniliśmy te kody.