ValExi's questions

De uma pergunta anterior, sei que ao chamar ~base()uma classe derivada, ela primeiro constrói um objeto base temporário, depois invoca a base temporária operator~()no objeto temporário e, finalmente, destrói o objeto temporário.

Entretanto, quando a classe base não tem um operator~, chamar base::~base()a classe derivada ainda pode invocar o destruidor da classe base.

Por que ocorre um erro quando a classe base tem um operator~?

#include <iostream>
using namespace std;
class base
{
public:
    base(){cout << "constructor base \n";}
    ~base(){cout << "destructor base \n";}
    void operator~(){cout << "operator ~ \n";}
};

class derived : public base
{
public:
    derived(){cout << "constructor derived \n";}
    ~derived(){base::~base();cout << "destructor derived \n";}
};

Informações sobre a versão do compilador:

g++.exe (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 8.1.0
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Erro:

cmd /c chcp 65001>nul && C:\mingw64\bin\g++.exe -fdiagnostics-color=always -g "D:\Valkyrie-text\simple text\text.cpp" -o "D:\Valkyrie-text\simple text\text.exe"
D:\Valkyrie-text\simple text\text.cpp: In destructor 'derived::~derived()':
D:\Valkyrie-text\simple text\text.cpp:15:28: error: no matching function for call to 'derived::~derived()'
     ~derived(){base::~base();cout << "destructor derived \n";}
                            ^
D:\Valkyrie-text\simple text\text.cpp:7:5: note: candidate: 'base::~base()'
     ~base(){cout << "destructor base \n";}
     ^
D:\Valkyrie-text\simple text\text.cpp:7:5: note:   candidate expects 1 argument, 0 provided

Em C++, por que uma classe derivada não pode chamar direta e explicitamente o destruidor de sua classe base sem usar um operador de resolução de escopo?

Ouvi dizer que em C++ todos os destruidores são processados ​​pelo compilador em "destrutor", o que significa que os destruidores das classes base e derivadas têm o mesmo nome, levando à redefinição (ocultação).

Isso está correto?

#include <iostream>
 
struct base {
    base() { std::cout << "base default \n"; }
    ~base() { std::cout << "~base \n"; }
};
 
struct derived : base {
    derived() { std::cout << "derived default \n"; }
    ~derived()
    {
        //~base();No
        base::~base();
        std::cout << "~derived \n";
    }
};

Eu sei que na prática quase não há necessidade de fazer isso, só quero entender o princípio...