Professional Documents
Culture Documents
Structures & Destructures of C++
Structures & Destructures of C++
AND
DESTRUCTOR
C++ Language
Constructors
A constructor in C++ is a special method that is automatically called when an object of a class is created.
To create a constructor, use the same name as the class, followed by parentheses ():
EXAMPLE:
#include <iostream>
using namespace std;
class MyClass { // The class
public: // Access specifier
MyClass() { // Constructor
cout << "Hello World!";
}
};
int main() {
MyClass myObj;
return 0;
}
Constructor Parameters ● Constructors can also take parameters (just like regular
functions), which can be useful for setting initial values for
attributes.
● The following class have brand, model and year attributes, and
a constructor with different parameters. Inside the constructor
we set the attributes equal to the constructor parameters
(brand=x, etc). When we call the constructor (by creating an
object of the class), we pass parameters to the constructor,
which will set the value of the corresponding attributes to the
same:
#include <iostream>
using namespace std;
// Print values
cout << carObj1.brand << " " << carObj1.model << " " << carObj1.year << "\n";
cout << carObj2.brand << " " << carObj2.model << " " << carObj2.year << "\n";
return 0;
}
EXAMPLE 2:
#include <iostream>
using namespace std;
class Car { // The class
public: // Access specifier
string brand; // Attribute
string model; // Attribute
int year; // Attribute
Car(string x, string y, int z); // Constructor declaration
};
// Constructor definition outside the class
Car::Car(string x, string y, int z) {
brand = x;
model = y;
year = z;
}
int main() {
// Create Car objects and call the constructor with different values
Car carObj1("BMW", "X5", 1999);
Car carObj2("Ford", "Mustang", 1969);
// Print values
cout << carObj1.brand << " " << carObj1.model << " " << carObj1.year
<< "\n";
cout << carObj2.brand << " " << carObj2.model << " " << carObj2.year
<< "\n";
return 0;
}
What is destructor?
Destructor is an instance member function which is invoked
automatically whenever an object is going to destroy. Means, a
destructor is the last function that is going to be called before an
object is destroyed.
The thing to be
noted is that Syntax:
destructor doesn’t ~constructor-name();
destroys an object.
● Destructor function is automatically invoked when the objects
are destroyed.
● It cannot be declared static or const.
Properties of
Destructor:
● The destructor does not have arguments.
● It has no return type not even void.
● An object of a class with a Destructor cannot become a
member of the union.
● A destructor should be declared in the public section of the
class.
● The programmer cannot access the address of destructor.
A destructor function is called automatically when the object goes
out of scope:
When is destructor
(1) the function ends
(2) the program ends
called?
member function?
Example:
class String {
private:
char* s;
int size;
public:
String(char*); // constructor
~String(); // destructor };
String::String(char* c)
{ size = strlen(c);
strcpy(s, c); }
String::~String() { delete[] s; }
When do we need to write a user-
defined destructor?
Points To Be Noted If we do not write our own destructor in
class, compiler creates a default destructor
Can there be more for us. The default destructor works fine
than one destructor in unless we have dynamically allocated
a class? memory or pointer in class. When a class
contains a pointer to memory allocated in
No, there can only one
class, we should write a destructor to
destructor in a class with
release memory before the class instance is
classname preceded by ~, destroyed. This must be done to avoid
no parameters and no memory leak.
return type.
Thank You
Coming up next:
Access Specifiers
in C++