How To Create a Vector of Pointers in C++

            
#include <iostream>  // For input/output
#include <vector>    // To use std::vector
#include <string>    // For std::string

// Base class: Animal
class Animal {
public:
    // A virtual function for polymorphism
    virtual std::string getDescription() const {
        return "Animal";
    }
};

// Derived class: Dog, inherits from Animal
class Dog : public Animal {
    std::string breed; // A specific attribute for Dog
public:
    // Constructor to initialize the breed
    Dog(const std::string& b) : breed(b) {}

    // Override the base class method to provide specific behavior
    std::string getDescription() const override {
        return "Dog of breed " + breed;
    }
};

int main() {
    // A vector of Animal objects (not pointers)
    std::vector<Animal> animals;

    // Add a Dog object to the vector
    animals.push_back(Dog("Golden Retriever"));
    // Object slicing occurs here:
    // - The Dog object is "sliced" into its Animal base class portion.
    // - The 'breed' data and the overridden 'getDescription' method are lost.

    // Attempt to call getDescription() on the first element of the vector
    std::cout << animals[0].getDescription() << std::endl;
    // Output: "Animal"
    // Explanation:
    // - Since the object was sliced, only the base class version of getDescription() is accessible.
    // - The derived class-specific implementation and data are no longer available.

    return 0;
}
        

            
#include <iostream>  // For input/output operations
#include <vector>    // For std::vector
#include <string>    // For std::string

// Base class: Animal
class Animal {
protected:
    std::string name; // Name of the animal
public:
    // Constructor to initialize the name
    Animal(const std::string& n) : name(n) {}

    // Pure virtual function to enforce implementation in derived classes
    virtual std::string getDescription() const = 0;

    // Virtual destructor to ensure proper cleanup of derived objects
    virtual ~Animal() = default;
};

// Derived class: Dog, inherits from Animal
class Dog : public Animal {
    std::string breed; // Additional attribute specific to Dog
public:
    // Constructor to initialize name and breed
    Dog(const std::string& n, const std::string& b)
        : Animal(n), breed(b) {}

    // Override the base class method to provide specific behavior
    std::string getDescription() const override {
        return name + " is a " + breed + " dog.";
    }
};

int main() {
    // A vector of pointers to Animal objects
    std::vector<Animal*> animals;

    // Dynamically allocate a Dog object and store the pointer in the vector
    animals.push_back(new Dog("Rex", "German Shepherd"));

    // Loop through the vector and call getDescription() on each Animal pointer
    for (const auto* animal : animals) {
        std::cout << animal->getDescription() << std::endl;
    }

    // Cleanup: Manually delete each dynamically allocated object
    for (auto* animal : animals) {
        delete animal;
    }

    // Clear the vector to remove dangling pointers
    animals.clear();

    return 0;
}
        

            
#include <vector> // For std::vector

// A simple class to demonstrate the concept
class MyClass {};

int main() {
    MyClass obj1, obj2;

    // Attempting to create a vector of references
    // This won't compile because references must be initialized
    std::vector<MyClass&> vec_refs; // Error: References are not allowed in containers

    // Even if we could create the vector, we couldn't add elements to it
    // vec_refs.push_back(obj1); // Error: References cannot be reassigned or stored

    return 0;
}
        

            
#include <iostream>       // For std::cout
#include <vector>         // For std::vector
#include <functional>     // For std::reference_wrapper

class MyClass {
    int id; // Unique identifier for each object
public:
    MyClass(int i) : id(i) {} // Constructor to initialize the ID
    void display() const {
        std::cout << "MyClass object with ID: " << id << std::endl;
    }
};

int main() {
    // Create MyClass objects
    MyClass obj1(1), obj2(2);

    // Create a vector of std::reference_wrapper to store references
    std::vector<std::reference_wrapper<MyClass>> vec_refs;

    // Add references to the vector using std::ref
    vec_refs.push_back(std::ref(obj1));
    vec_refs.push_back(std::ref(obj2));

    // Print message showing objects are added
    std::cout << "Objects added to vector of references." << std::endl;

    // Access and display the objects via the vector
    std::cout << "Accessing objects via vector:" << std::endl;
    vec_refs[0].get().display(); // Retrieve and display the first reference
    vec_refs[1].get().display(); // Retrieve and display the second reference

    // Modify an object via the reference in the vector
    std::cout << "Modifying obj1 via vector..." << std::endl;
    vec_refs[0].get() = MyClass(10); // Reassign obj1 through the vector

    // Display the modified objects
    std::cout << "After modification:" << std::endl;
    vec_refs[0].get().display(); // Display the modified obj1
    vec_refs[1].get().display(); // Display obj2 (unchanged)

    return 0;
}
        

            
#include <iostream>      // For input/output operations
#include <vector>        // For std::vector
#include <memory>        // For smart pointers like std::unique_ptr
#include <string>        // For std::string

// Base class: Animal
class Animal {
public:
    // Pure virtual function to enforce implementation in derived classes
    virtual std::string getDescription() const = 0;

    // Virtual destructor ensures proper cleanup for derived objects
    virtual ~Animal() = default;
};

// Derived class: Dog, inherits from Animal
class Dog : public Animal {
    std::string breed; // Additional attribute specific to Dog
public:
    Dog(const std::string& b) : breed(b) {}

    // Override the base class method to provide specific behavior
    std::string getDescription() const override {
        return "Dog of breed: " + breed;
    }
};

// Derived class: Cat, inherits from Animal
class Cat : public Animal {
    bool isIndoor; // Specific attribute for Cat
public:
    Cat(bool indoor) : isIndoor(indoor) {}

    // Override to describe the Cat
    std::string getDescription() const override {
        return isIndoor ? "Indoor Cat" : "Outdoor Cat";
    }
};

// Derived class: Bird, inherits from Animal
class Bird : public Animal {
    std::string species; // Specific attribute for Bird
public:
    Bird(const std::string& s) : species(s) {}

    // Override to describe the Bird
    std::string getDescription() const override {
        return "Bird of species: " + species;
    }
};

int main() {
    // Create a vector of unique_ptr to Animal objects
    std::vector<std::unique_ptr<Animal>> animals;

    // Add different types of animals to the vector using std::make_unique
    animals.push_back(std::make_unique<Dog>("German Shepherd"));
    animals.push_back(std::make_unique<Cat>(true)); // Indoor Cat
    animals.push_back(std::make_unique<Bird>("Parrot"));

    // Iterate through the vector and call getDescription() on each Animal
    std::cout << "Descriptions of Animals in the vector:" << std::endl;
    for (const auto& animal : animals) {
        std::cout << animal->getDescription() << std::endl;
    }

    // Smart pointers automatically clean up resources when they go out of scope
    return 0;
}