Join Regular Classroom : Visit ClassroomTech

Programming in C++ – codewindow.in

/ Programming in C++ / By

Related Topics

C++ Programing

#include 

// Engine class
class Engine {
public:
    Engine(int displacement) : displacement(displacement) {}

    void start() {
        std::cout << "Engine started." << std::endl;
    }

private:
    int displacement;
};

// Car class with a member object of type Engine
class Car {
public:
    Car(int year, int engineDisplacement) : manufactureYear(year), carEngine(engineDisplacement) {}

    void start() {
        carEngine.start();
        std::cout << "Car started." << std::endl;
    }

private:
    int manufactureYear;
    Engine carEngine;  // Member object
};

int main() {
    Car myCar(2023, 2000);
    myCar.start();

    return 0;
}

In this example, we have two classes: Engine and Car. The Engine class represents an engine with a displacement, and the Car class represents a car with a manufacture year and an engine member object. The Car class includes an instance of the Engine class as a member object.

When you create an instance of the Car class, it contains a member object of type Engine. This demonstrates composition, where a larger class (Car) is composed of smaller classes (Engine). The start method in the Car class uses the start method of the Engine member object before displaying a message about starting the car.

Member objects allow you to create more modular and reusable code by encapsulating functionality into smaller, specialized classes. This promotes code organization, separation of concerns, and code reuse.

#include 
#include 

// Address class
class Address {
public:
    Address(const std::string& street, const std::string& city, const std::string& country)
        : streetAddress(street), city(city), country(country) {}

    std::string getFullAddress() const {
        return streetAddress + ", " + city + ", " + country;
    }

private:
    std::string streetAddress;
    std::string city;
    std::string country;
};

// Person class with a member object of type Address
class Person {
public:
    Person(const std::string& name, const Address& addr) : fullName(name), address(addr) {}

    void displayInfo() const {
        std::cout << "Name: " << fullName << std::endl;
        std::cout << "Address: " << address.getFullAddress() << std::endl;
    }

private:
    std::string fullName;
    Address address;  // Member object
};

int main() {
    Address johnsAddress("123 Main St", "Cityville", "Countryland");
    Person john("John Doe", johnsAddress);

    john.displayInfo();

    return 0;
}

In this example:

  1. The Address class defines an Address object with data members representing street address, city, and country. It also has a method to retrieve the full address.

  2. The Person class has a member object of type Address, representing the person’s address. The class also includes methods to set and display the person’s information.

  3. In the main function, we create an Address object for John’s address and then use this object to create a Person object named john. The john object contains the member object of type Address.

  4. Finally, we call the displayInfo method on the john object to display both the person’s name and address.

This example demonstrates how the member object (Address) is part of the Person class and is stored as a data member within the class. The composition of classes using member objects allows for more organized and modular code design.

class Person {
private:
    std::string name;  // Data member representing the person's name

public:
    int age;           // Data member representing the person's age (public for simplicity)
};

In this example, name and age are data members of the Person class.

  1. Member Object: A member object is an instance of a class that is declared as a data member within another class. It represents a composition or aggregation relationship between classes, where one class includes an instance of another class to build more complex structures. The member object itself is a data member of the containing class, but it’s of a different class type.

Example:

class Car {
private:
    Engine carEngine;  // Member object of type Engine

public:
    // Other data members and methods for the Car class
};

In this example, carEngine is a member object of the Car class. It’s an instance of the Engine class, which is declared within the Car class.

To summarize, a data member is a variable that holds a specific value associated with an object, while a member object is an instance of another class that is included as a data member within the containing class to create more complex structures.

#include 

class Point {
public:
    Point(int xCoord, int yCoord) : x(xCoord), y(yCoord) {}

    void display() const {
        std::cout << "(" << x << ", " << y << ")";
    }

private:
    int x;
    int y;
};

class Rectangle {
public:
    Rectangle(int width, int xCoord, int yCoord) : rectWidth(width), topLeft(xCoord, yCoord) {}

    void displayInfo() const {
        std::cout << "Rectangle Width: " << rectWidth << std::endl;
        std::cout << "Top Left Corner: ";
        topLeft.display();
        std::cout << std::endl;
    }

private:
    int rectWidth;  // Data member
    Point topLeft;  // Member object of type Point
};

int main() {
    Rectangle rect(10, 3, 5);
    rect.displayInfo();

    return 0;
}

In this example:

  1. The Point class defines an object with data members x and y to represent coordinates. It also has a display method to print the coordinates.

  2. The Rectangle class has a data member rectWidth representing the width of the rectangle. It also has a member object topLeft of type Point representing the top-left corner of the rectangle.

  3. The main function creates a Rectangle object named rect with a width of 10 and a top-left corner at coordinates (3, 5). The displayInfo method is called to display information about the rectangle.

This example demonstrates that:

  • The rectWidth is a data member within the Rectangle class that holds a simple value (width).

  • The topLeft member object is an instance of the Point class, which has its own state and behavior (coordinates and display method).

The distinction between data members and member objects becomes apparent when you consider that member objects are entire instances of other classes, whereas data members are typically simple variables that store values.

#include 

class OuterClass {
public:
    // OuterClass constructor
    OuterClass(int value) : outerValue(value) {}

    void outerMethod() {
        std::cout << "OuterClass method" << std::endl;
    }

    class InnerClass {
    public:
        // InnerClass constructor
        InnerClass(int value) : innerValue(value) {}

        void innerMethod() {
            std::cout << "InnerClass method" << std::endl;
        }

    private:
        int innerValue;
    };

private:
    int outerValue;
};

int main() {
    OuterClass outerObj(42);
    OuterClass::InnerClass innerObj(23);

    outerObj.outerMethod();   // Call outer method
    innerObj.innerMethod();   // Call inner method

    return 0;
}

In this example:

  1. The OuterClass is defined, and within it, an InnerClass is also defined.

  2. Both classes have their own methods and data members.

  3. In the main function, we create instances of both OuterClass and InnerClass and call their methods.

Note that when accessing the inner class from outside the outer class, you need to use the scope resolution operator (::) with the outer class name, like OuterClass::InnerClass.

Class nesting can be useful for organizing related classes, encapsulating functionality, and achieving a more structured design. However, excessive nesting can lead to increased complexity, so it’s important to use it judiciously and consider whether it truly enhances the clarity of your code.

#include 

class MyClass {
public:
    static int staticData;  // Static data member

    static void staticMethod() {
        std::cout << "Static method called." << std::endl;
    }

    void displayData() {
        std::cout << "Static data: " << staticData << std::endl;
    }
};

// Initialize static data member
int MyClass::staticData = 42;

int main() {
    MyClass::staticMethod();  // Call static method

    MyClass obj1;
    obj1.displayData();  // Access static data member using an instance

    MyClass obj2;
    obj2.displayData();  // Static data member is shared among instances

    return 0;
}

In this example:

  • staticData is a static data member shared among all instances of MyClass.

  • staticMethod is a static member function.

  • The main function demonstrates how to access and use static members.

Static members are typically used when you need to maintain information or behavior that is common to the entire class and not tied to individual instances.

#include 

class Counter {
public:
    static int count;  // Static data member

    Counter() {
        count++;  // Increment the static count for each object created
    }
};

// Initialize static data member
int Counter::count = 0;

int main() {
    Counter obj1;  // Creates the first object
    Counter obj2;  // Creates the second object

    std::cout << "Count: " << Counter::count << std::endl;  // Display the shared count

    return 0;
}

In this example:

  • The Counter class has a static data member named count, which will be shared among all objects of the class.

  • The constructor of the Counter class increments the count every time a new object is created.

  • The main function creates two Counter objects, and after that, it displays the value of the shared count.

When you run this code, you’ll see that the static data member count is incremented for each object created, and the final value displayed in the main function will reflect the total count across all objects. This behavior demonstrates that the static data member is shared among all objects of the class and is not associated with any specific instance.

The key takeaway is that static members, including static data members, are properties of the class itself and are not tied to individual objects.

      

Click here For Latest Job Openings
Telegram Facebook Linkedin Instagram

Click to Join:

Join Telegram
Study Material
Join Facebook
Join LinkedIn

Popular Category

Job Information
Quiz Assessment
TCS Mock Test
Data Structure / Algo
Interview Experience
Tech Mahindra

Topics for You

Go through our study material. Your Job is awaiting.

Study Material
Recent Posts
Categories