In C++, constructors and destructors are used to initialize and clean up the state of objects, respectively. When a class hierarchy is involved, there are specific rules for how constructors and destructors are invoked.

Constructors:

When an object of a derived class is created, its constructor is called. Before that, the constructor of its base class is called. This happens recursively for all the base classes of the derived class until the constructor of the top-most base class is called. This process is called constructor chaining.

For example, let's consider a class hierarchy that involves a base class Animal and a derived class Dog. The Dog class inherits from the Animal class. When an object of the Dog class is created, the constructor of the Animal class is called first, followed by the constructor of the Dog class.

class Animal {
public:
    Animal() {
        // constructor code for Animal
    }
};

class Dog : public Animal {
public:
    Dog() {
        // constructor code for Dog
    }
};

Destructors:

When an object is destroyed, the destructor of its class is called. Before that, the destructor of its base class is called. This happens recursively for all the base classes of the derived class until the destructor of the top-most base class is called. This process is called destructor chaining.

For example, let's consider the same class hierarchy involving the Animal and Dog classes. When an object of the Dog class is destroyed, the destructor of the Dog class is called first, followed by the destructor of the Animal class.

class Animal {
public:
    ~Animal() {
        // destructor code for Animal
    }
};

class Dog : public Animal {
public:
    ~Dog() {
        // destructor code for Dog
    }
};

It's important to note that if the base class has a virtual destructor, the derived class should also have a virtual destructor. This allows the correct destructor to be called when deleting an object through a pointer to the base class.

class Animal {
public:
    virtual ~Animal() {
        // virtual destructor code for Animal
    }
};

class Dog : public Animal {
public:
    virtual ~Dog() {
        // virtual destructor code for Dog
    }
};

In conclusion, constructors and destructors are invoked in class hierarchies using constructor chaining and destructor chaining, respectively. The order in which they are called is determined by the hierarchy of the classes, with the base class constructor or destructor being called first, followed by the derived class constructor or destructor.