C++ Lesson 02: Classes and Objects

In C++, the struct is expanded to contain data (variables) and functions. All the data and functions can be assigned to different access sections: private, protected, and public. It has the same capabilities as a class, except that. By default, a structure's members are public. The general form of a C++ structure is:

struct class_name : inheritance_list {
public:
    // public members by default
protected:
    // private members that can be inherited
privated:
    // private members
} object_list;

The class_name is the type name of the structure, which is a class type. The individual members are referenced using the dot (.) operator when acting on an object or by using the arrow (->) operator when acting through a pointer to the object. The object_list and inheritance_list are optional.

Understanding the Similarities and Differences between Struct and Class in C++

Struct and class, two fundamental data structures in C++, often raise questions about their distinctions and similarities. This article provides a clear overview of the shared features and contrasting aspects of structs and classes, equipping you with the knowledge to make informed decisions when selecting the appropriate data structure for your programming needs.

Similarities

Both structs and classes are user-defined data types that allow you to group related variables and functions together. They both support the following features:

• Member variables: You can declare member variables of different data types within structs and classes.
• Member functions: You can define member functions within structs and classes to perform operations on the data members.
• Objects: You can create objects from both structs and classes to represent instances of the data structure.
• Constructors and Destructors: Both structs and classes can have constructors to initialize objects and destructors to clean up resources when objects are destroyed.
• Inheritance: Both structs and classes support inheritance, allowing you to create new data types that inherit properties and functionalities from existing ones.
• Access Specifiers: Both structs and classes support access specifiers (public, private, protected) to control the accessibility of member variables and functions.

Differences

Despite their similarities, structs and classes exhibit some key differences:

In summary, structs are lightweight data structures primarily intended for grouping related data, while classes are more complex and versatile, enabling data abstraction, inheritance, and encapsulation. The choice between struct and class depends on the specific requirements of your application.

#include <stdio.h>
#include <iostream>
using namespace std;

typedef struct STUDENTINFO{
private:
    int     age;
    string  name;
public:
    void    SetAge(int a);
    void    SetName(string n);
    void    PrintInfo();
} STUDENTINFO;
//------------------------------------------------------------------------------
int main()
{
    STUDENTINFO  Student;
    string  name;
    int     age;

    age  = 16;
    name = "Ryan";

    Student.SetAge(age);
    Student.SetName(name);

    Student.PrintInfo();

    return 0;
}
//------------------------------------------------------------------------------
void STUDENTINFO::SetAge(int a)
{
    age = a;
}
void STUDENTINFO::SetName(string n)
{
    name = n;
}
void STUDENTINFO::PrintInfo()
{
    cout << "Name: " << name << endl;
    cout << "Age: " << age << endl;
}
//------------------------------------------------------------------------------

Classes

C++ creates a new user-defined data type — class. It is similar to the struct (structure), but some differences remain.

In C++, a class is a blueprint for creating objects. It defines the characteristics and behavior of a particular type of object. A class encapsulates data members (attributes) and member functions (methods) that define the properties and operations associated with that type of object.

Key characteristics of classes:

• User-defined data type: Classes are user-defined data types, allowing programmers to create new data structures tailored to specific requirements.
• Data encapsulation: Classes encapsulate data members, hiding them from direct access and controlling their modification through member functions.
• Data abstraction: Classes provide a layer of abstraction, hiding the implementation details of the object's data and behavior, exposing only the essential functionalities to the user.
• Code organization: Classes promote code organization by grouping related data and functions, enhancing maintainability and readability.

Components of a class:

• Data members: Data members represent the attributes of an object, such as its name, age, or salary. They are declared within the class using data types like int, string, or bool.
• Member functions: Member functions define the behavior of an object, specifying the actions it can perform. They are declared within the class using a return type, function name, and parentheses for parameters.

A class is a basic unit of encapsulation in C++. Its general form is as follows:

class class_name : inheritance_list {
    // private members by default
private:
    // private members
protected:
    // private members that can be inherited
public:
    // public members
} object_list;

A class in C++ is a user-defined data type that can hold its own data members and member functions in a block. The member data and functions in the class can be stored in different access sections: private, protected, and public. The default access section for the class is private. The class is similar to a struct, but the default access section is the public in a struct.

class Student {
public:
    string  name;
    int     age;
    int     rollNum;

    void introduce() {
        cout << "Hello! My name is " << name << ", and I am " << age << " years old." << endl;
    }
};

Objects

An object is an instance of a class. It represents a concrete entity with the characteristics and behavior defined by the class. Objects are created using the class name and a pair of parentheses, often with initialization values.

Creating objects:

Student s1; // Creates an object named s1 of type Student
Student s2("Alice", 18, 12345); // Creates an object named s2 of type Student, initializing its data members

Accessing class members:

• Data members: Access data members using the dot (.) operator followed by the member name.
  

  cout << s1.name << endl; // Outputs the name of s1

• Member functions: Call member functions using the dot (.) operator followed by the function name and parentheses for arguments.
  

  s2.introduce(); // Calls the introduce() function of s2

Objects are the fundamental building blocks of object-oriented programming. They encapsulate data and behavior, enabling programmers to create reusable and modular components that interact with each other to solve complex problems.

In summary, classes and objects are essential concepts in C++ object-oriented programming. Classes provide blueprints for creating objects defining their data members and member functions. Objects, instances of classes, represent concrete entities with the characteristics and behavior defined by the class. Classes and objects enable programmers to model real-world entities and their interactions, creating well-structured and maintainable software solutions.

Constructors

In C++, a constructor is a special member function that is called automatically when an object of a class is created. It is used to initialize the object's data members with appropriate values. Constructors are essential to object-oriented programming, ensuring that objects are initialized consistently and well-defined.

Key characteristics of constructors:

• Same name as the class: Constructors have the same name as their class.
• No return type: Constructors do not have a return type, as they are responsible for initializing the object rather than returning a value.
• Parameter list: Constructors can have a parameter list for different ways of initializing objects.
• Access control: Constructors can have access specifiers (public, private, protected) to control their accessibility.

Types of constructors:

• Default constructor: A default constructor is a constructor that takes no arguments. It is used to initialize objects with default values.
• Parameterized constructor: A parameterized constructor is a constructor that takes one or more arguments. It allows for more flexibility in initializing objects with different values.
• Copy constructor: A copy constructor is a constructor that creates a new object by copying the values from an existing object. It is used to initialize objects from other objects of the same class.

class Person {
public:
  Person() {
    name = "John Doe";
    age = 30;
  }

  string name;
  int age;
};

class Student {
public:
    Student(string name, int age, int rollNum) {
        this->name = name;
        this->age  = age;
        this->rollNum = rollNum;
    }
    string  name;
    int     age;
    int     rollNum;
};

class Employee {
public:
    Employee(string name, string department) {
        this->name = name;
        this->department = department;
    }

    Employee(const Employee& other) {
        name = other.name;
        department = other.department;
    }

    string name;
    string department;
};

Destructors

In C++, a destructor is a special member function that is called automatically when an object of a class is destroyed. It is responsible for cleaning up any resources associated with the object, such as releasing allocated memory or closing open files. Destructors are essential to object-oriented programming, ensuring that objects are cleaned up properly, and resources are not leaked.

Key characteristics of destructors:

• Same name as the class: Destructors have the same name as the class they belong to, preceded by a tilde (~) symbol.
• No return type: Destructors do not have a return type, as they are responsible for cleaning up the object rather than returning a value.
• No parameter list: Destructors do not have a parameter list, as they are associated with a specific object and do not require additional input.
• Access control: Destructors can have access specifiers (public, private, protected) to control their accessibility.

Purpose of destructors:

• Release memory: Destructors are primarily responsible for releasing memory allocated for the object during its lifetime.
• Close resources: Destructors can also be used to close open files, handles, or other resources acquired by the object.
• Perform cleanup tasks: Destructors can perform necessary cleanup tasks, such as updating shared data structures or removing temporary files.

class File {
public:
    File(string filename) {
        filePointer = fopen(filename.c_str(), "r");
    }

    ~File() {
        if (filePointer) {
            fclose(filePointer);
        }
    }

private:
    FILE *filePointer;
};

In this example, the File class has a destructor that closes the file pointer opened in the constructor. This ensures that the file is properly closed when the File object is destroyed.

Importance of destructors:

Destructors are crucial for resource management and preventing memory leaks in C++. Destructors help maintain program efficiency and prevent system instability by ensuring that objects are cleaned up properly. They also promote code reusability and maintainability by encapsulating cleanup logic within the class.

In summary, destructors are essential components of object-oriented programming in C++. They are vital in resource management, memory deallocation, and overall program correctness. By providing a structured mechanism for object cleanup, destructors contribute to a more efficient and reliable programming environment.

Access specifiers are keywords used in C++ to control the accessibility of class members (data members and member functions) to other classes and objects. They define the visibility of these members, determining which parts of a class can be accessed from outside the class itself.

Types of Access Specifiers

C++ provides three access specifiers:

class Student {
public:
    string name;
    int age;

    void printDetails() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

class Shape {
protected:
    double width;
    double height;

public:
    void setDimensions(double w, double h) {
        width = w;
        height = h;
    }

    double getArea() {
        return width * height;
    }
};

class Rectangle : public Shape {
public:
    double getPerimeter() {
        return 2 * (width + height);
    }
};

class Account {
private:
    int balance;

public:
    void deposit(int amount) {
        balance += amount;
    }

    void withdraw(int amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            cout << "Insufficient funds" << endl;
        }
    }

    int getBalance() {
        return balance;
    }
};

class Student {
private:
    string name;
    int age;
    double gpa;

public:
    void setName(const string& newName) {
        name = newName;
    }

    void setAge(int newAge) {
        age = newAge;
    }

    void setGPA(double newGPA) {
        gpa = newGPA;
    }

    string getName() const {
        return name;
    }

    int getAge() const {
        return age;
    }

    double getGPA() const {
        return gpa;
    }
};

class Shape {
protected:
    double width;
    double height;

public:
    void setDimensions(double w, double h) {
        width = w;
        height = h;
    }

    double getArea() {
        return width * height;
    }
};

class Rectangle : public Shape {
public:
    double getPerimeter() {
        return 2 * (width + height);
    }
};

class Bank {
protected:
    double balance;
    int accountNumber;

public:
    void deposit(int amount) {
        balance += amount;
    }

    void withdraw(int amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            cout << "Insufficient funds" << endl;
        }
    }

    int getAccountNumber() const {
        return accountNumber;
    }
};

class SavingsAccount : public Bank {
public:
    void applyInterest() {
        balance *= 1.01;
    }
};

Choosing the Right Access Specifier

The choice of access specifier depends on the desired level of encapsulation and control over class members. Public members are widely accessible, while private members provide the highest level of encapsulation. Protected members allow controlled access within the class hierarchy.

In general, it is recommended to use private members for data members that should not be directly modified from outside the class. Public members should be used for methods that provide controlled access to data members or perform specific operations. Protected members are useful when sharing data or functionality between a base class and its derived classes.

By carefully choosing the appropriate access specifiers, you can achieve better data protection, modularity, and maintainability in your C++ programs.

Accessing Class Members in C++

In C++, class members (data members and member functions) are the building blocks of classes. They define the data and behavior of the class and determine how objects of that class can interact with the class and with each other. Accessing class members is a fundamental aspect of using C++ classes effectively.

Access Specifiers

C++ provides access specifiers that control the accessibility of class members. These access specifiers determine which parts of a class can be accessed from outside the class itself. The three main access specifiers are:

• Public: Public members are accessible from anywhere in the program, including outside the class itself.
• Private: Private members are only accessible within the class itself.
• Protected: Protected members are accessible within the class itself and within derived classes (classes that inherit from the base class).

Accessing Class Members Using Objects

Objects are instances of classes that represent real-world entities or concepts. To access class members using objects, the dot notation (.) is used. For example, if obj is an object of class MyClass, and member is a class member, then the following syntax is used to access the member:

obj.nember

For example, if MyClass has a public data member named name and a public member function named printDetails(), then the following code can be used to access these members:

MyClass obj;
obj.name = "John Doe";
obj.printDetails();

Accessing Class Members Using Static Members

Static members are class members that are not associated with any particular object of the class. They are accessible using the class name itself, not through an object. Static data members are accessed using the scope resolution operator (::), while static member functions are accessed using the class name followed by the scope resolution operator and the member function name.

For example, if MyClass has a static data member named count and a static member function named printCount(), then the following code can be used to access these members:

MyClass::count = 10;
MyClass::printCount();

Accessing Class Members from Derived Classes

Derived classes inherit members from their base classes. Inherited members can be accessed using the dot notation (.) with an object of the derived class. Protected members of the base class can also be accessed from derived classes using the dot notation.

For example, if MyClass has a protected data member named width and a protected member function named setWidth(), and Rectangle is a class derived from MyClass, then the following code can be used to access these members:

MyClass::count = 10;
MyClass::printCount();

Accessing Class Members from Derived Classes

Derived classes inherit members from their base classes. Inherited members can be accessed using the dot notation (.) with an object of the derived class. Protected members of the base class can also be accessed from derived classes using the dot notation.

For example, if MyClass has a protected data member named width and a protected member function named setWidth(), and Rectangle is a class derived from MyClass, then the following code can be used to access these members:

Rectangle rect;
rect.setWidth(10);

Accessing class members is essential for utilizing classes and objects effectively in C++. By understanding the different access specifiers and the syntax for accessing members using objects, static members, and derived classes, programmers can write well-structured, maintainable, and reusable C++ code.