Can destuctors be private in C++?

What’s the order that sub-objects of an object are destructed?

struct Base0
{
    ~Base0() {};
};
struct Base1
{
    ~Base1() {};
};
struct Member0
{
    ~Member0() {};
};
struct Member1
{
    ~Member1() {};
};
struct Local0
{
    ~Local0()
    {

    };
};
struct Local1
{
    ~Local1()
    {

    };
};
struct Derived: Base0, Base1
{
    Member0 m0_;
    Member1 m1_;
    ~Derived()
    {
        Local0 l0;
        Local1 l1;
    }
};


int main()
{
    Derived d;

    return 0;
}

Like constructors, can there be more than one destructors in a class?

What’s the order that local objects are destructed?

int main()
{
    Test obj1;
    
    Test obj2;
    
    return 0;
}

Predict the output of following C++ progran

#include <iostream>
using namespace std;
  
int i;
  
class A
{
public:
    ~A()
    {
        i=10;
    }
};
  
int foo()
{
    i=3;
    A ob;
    return i;
}
  
int main()
{
    cout << foo() << endl;
    return 0;
}

Could we destroy local objects within the function?

Which of the following statements are not true about destructor?

1. It is invoked when the object goes out of the scope
2. Like a constructor, it can also have parameters
3. It can be virtual
4. It bears the same name as that of the class and precedes the Lambda sign.

Can destructors be virtual in C++?

What’s the order that objects in an array are destructed?

int main()
{
    Test obj[5]; //array of Test class object
        
    return 0;
}

When I write a derived class’s destructor, do I need to explicitly call the destructor for my base class?

#include <iostream>
using namespace std; 
class A
{
    int id;
    static int count;
public:
    A() {
        count++;
        id = count;
        cout << "constructor for id " << id << endl;
    }
    ~A() {
        cout << "destructor for id " << id << endl;
    }
};
  
int A::count = 0;
  
int main() {
    A a[3];
    return 0;
}

1. 

constructor for id 1
constructor for id 2
constructor for id 3
destructor for id 3
destructor for id 2
destructor for id 1

2. 

constructor for id 1
constructor for id 2
constructor for id 3
destructor for id 1
destructor for id 2
destructor for id 3

3. 

Compiler Dependent.

4. 

constructor for id 1
destructor for id 1

Can I overload the destructor for my class?

Should I explicitly call a destructor on a local variable?

Can I kill a local object by calling the destructor before going it out of the scope (Before the close } )