Constructorul implicit , în limbajele de programare orientate pe obiecte, este un constructor care poate fi apelat fără argumente .
În C++ și Java , dacă nu există constructori definiți în mod explicit într-o clasă , atunci compilatorul folosește constructorul implicit definit implicit și este de obicei un constructor nul. Dacă programatorul a specificat în mod explicit doar un constructor cu parametri, atunci compilatorul nu va crea un constructor implicit.
În C++ și Java, dacă clasa derivată nu apelează în mod explicit constructorul clasei de bază (în C++ în lista de inițializare, în Java super()în prima linie), atunci constructorul implicit este apelat implicit.
În C++ , standardul descrie un constructor implicit ca un constructor care poate fi apelat fără a trece argumente (inclusiv un constructor cu parametri care au o valoare implicită). [1] De exemplu:
clasa MyClass { public : Clasa mea (); // constructorul este declarat privat : int x ; }; MyClass :: MyClass () : x ( 100 ) // definit de constructor { } int main () { MyClass m ; // în timp ce programul rulează, un obiect m este creat ȘI constructorul implicit se numește }Când memoria este alocată dinamic pentru un obiect, constructorul poate fi apelat prin adăugarea de paranteze goale după numele clasei. Într-un fel, acesta este un apel explicit al constructorului:
int main () { MyClass * pointer = new MyClass (); // la runtime, obiectul este creat și // constructorul implicit este numit }Dacă un constructor are unul sau mai mulți parametri impliciti, acesta este totuși constructorul implicit. Fiecare clasă poate avea cel mult un constructor implicit, fie fără parametri, fie cu parametri impliciti, ca în acest exemplu:
clasa MyClass { public : MyClass ( int i = 0 , std :: string s = "" ); // constructorul este declarat (prototip) privat : int x ; int y ; std :: stringz ; _ }; MyClass :: MyClass ( int i , std :: string s ) // definit de constructor { x = 100 ; y = i ; z = s ; }În C++, constructorii impliciti sunt esențiali, deoarece sunt apelați automat în anumite circumstanțe și, prin urmare, în anumite condiții, o clasă trebuie să aibă un constructor implicit, altfel va apărea o eroare:
Dacă o clasă nu definește un constructor implicit, compilatorul va crea implicit unul. Va fi la fel ca un constructor declarat explicit cu un corp gol. De exemplu: [2]
clasa MyClass { int x ; }; int main () { MyClass m ; // nu există nicio eroare în timp ce programul rulează, constructorul implicit este numit }Dacă constructorii sunt definiți pentru o clasă, dar nu există niciun constructor implicit printre aceștia, compilatorul nu va genera implicit unul. Acest lucru are ca rezultat erori precum acest exemplu:
clasa MyClass { public : MyClass ( int y ); // declarație constructor non-implicit privat : int x ; }; MyClass :: MyClass ( int y ) { x = y _ } int main () { MyClass m ( 100 ); // constructor non-implicit numit MyClass * p ; // compilatorul nu trebuie să știe despre constructori când declară un pointer p = new MyClass (); // eroare la momentul compilării: niciun constructor implicit returnează 0 ; }Crearea unui obiect spre pcare s-a indicat va duce, de asemenea, la o eroare. [2]
Pe de altă parte, cu C++11 , constructorul implicit poate fi specificat în mod explicit:
clasa MyClass { public : MyClass () = implicit ; // forță generarea unui constructor implicit };Sau eliminat în mod explicit:
clasa MyClass { public : MyClass () = șterge ; // împiedică generarea constructorului implicit };