[go: up one dir, main page]
Scribd
Upload
13 views9 pages

Obj and Class Consructor

The document explains class methods in C++, detailing how to define methods both inside and outside class definitions. It also covers constructors, including their purpose and how to create them with or without parameters, as well as the concept of access specifiers (public, private, and protected) that control the accessibility of class members. Examples are provided to illustrate these concepts in practice.

Uploaded by

sundiidot123
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
13 views9 pages

Obj and Class Consructor

The document explains class methods in C++, detailing how to define methods both inside and outside class definitions. It also covers constructors, including their purpose and how to create them with or without parameters, as well as the concept of access specifiers (public, private, and protected) that control the accessibility of class members. Examples are provided to illustrate these concepts in practice.

Uploaded by

sundiidot123
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 9

Class Methods

Methods are functions that belongs to the class.


There are two ways to define functions that belongs to
a class:
•Inside class definition
•Outside class definition
In the following example, we define a function inside
the class, and we name it "myMethod".
Note: You access methods just like you access
attributes; by creating an object of the class and using
the dot syntax (.):
Inside Example
class MyClass { // The class
public: // Access specifier
void myMethod() { // Method/function defined
inside the class
cout << "Hello World!";
}
};

int main() {
MyClass myObj; // Create an object of MyClass
myObj.myMethod(); // Call the method
return 0;
}
Outside Example
To define a function outside the class definition, you have to declare it inside the class
and then define it outside of the class. This is done by specifying the name of the class,
followed the scope resolution :: operator, followed by the name of the function:

class MyClass { // The class


public: // Access specifier
void myMethod(); // Method/function declaration
};

// Method/function definition outside the class


void MyClass::myMethod() {
cout << "Hello World!";
}

int main() {
MyClass myObj; // Create an object of MyClass
myObj.myMethod(); // Call the method
return 0;
}
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
class MyClass { // The class
public: // Access specifier
MyClass() { // Constructor
cout << "Hello World!";
}
};

int main() {
MyClass myObj; // Create an object of MyClass (this will call the constructor)
return 0;
}

Note: The constructor has the same name as the class, it is always public,
and it does not have any return value.
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:
Example
class Car { // The class
public: // Access specifier
string brand; // Attribute
string model; // Attribute
int year; // Attribute
Car(string x, string y, int z) { // Constructor with parameters
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;
}
Access Specifiers
By now, you are quite familiar with the public keyword that appears in all of our class
examples:

Example
class MyClass { // The class
public: // Access specifier
// class members goes here
};
Access Specifiers
The public keyword is an access specifier. Access specifiers define how the members (attributes and methods) of a class
can be accessed. In the example above, the members are public - which means that they can be accessed and modified from
outside the code.
However, what if we want members to be private and hidden from the outside world?
In C++, there are three access specifiers:
•public - members are accessible from outside the class
•private - members cannot be accessed (or viewed) from outside the class
•protected - members cannot be accessed from outside the class, however, they can be accessed in inherited classes. You
will learn more about Inheritance later.
In the following example, we demonstrate the differences between public and private members:

Example
class MyClass {
public: // Public access specifier
int x; // Public attribute
private: // Private access specifier
int y; // Private attribute
};

int main() {
MyClass myObj;
myObj.x = 25; // Allowed (public)
myObj.y = 50; // Not allowed (private)
return 0;
}
Access Specifiers
By now, you are quite familiar with the public keyword that appears in all of our class
examples:

Example
class MyClass { // The class
public: // Access specifier
// class members goes here
};

You might also like