Deleting an object in C++ without creating it with new, or is it possible to delete objects by taking the address (&)?

Question

C++ / C#

Good day to all.
To face such a problem - you need to delete an object instance:

BaseClass BaseClassObj;
    /*
            Какой-то не очень важный код, который еще можно будет увидеть ниже.
   */

    // Разумеется это работать не будет ( кстати, очень интересно почему - ведь
    // по идее имя объекта это указатель на него, если у кого будет возможность 
    // объяснить этот момент - буду крайне признателен), ведь мы создали объект 
    // экземпляр объекта не использую new и указатель на объект.
    delete BaseClassObj;

In the end I tried this method:

BaseClass BaseClassObj;
    /*
            Какой-то не очень важный код, который еще можно будет увидеть ниже.
   */

    // Компилятор уже не ругается, но мы получаем очень интересный вывод в консоль.
    // В итоге если у нас деструктор срабатывает дважды, при одном созданном объекте,
    // один раз сейчас, второй раз после завершения main()
        delete &BaseClassObj;

It turns out interesting.
Below is the code and console output, in general, everything that prompted me to create this topic.
main.cpp :

#include "BaseClass.h"
using namespace std;

void BaseClassPresentation(){

    BaseClass BaseClassObj;
    BaseClassObj.Value2 = 15;
    std::cout<<"Value2 after resetting Value2. Get value like BaseClass::Value2 (static member of class) - "<<BaseClass::Value2 << std::endl;

    BaseClassObj.OverloadedFunction(1);
    BaseClassObj.OverloadedFunction(1,2);
    BaseClassObj.OverloadedFunction(13.2, 47.1);

    //  Мы НЕ можем таким образом удалить объект.
    //  Потому что удаление происходит через указатель.
    //  Объект BaseClassObj будет удален только по завершению программы.
    //    delete BaseClassObj;
    // или же....
    // При помощи оператора взятия ссылки (&).
        delete &BaseClassObj;

    //  Код ниже иллюстрирует как создать объект, чтобы его удалить, без использования операции взятия адреса
    BaseClass *BaseClassObjPtr = new BaseClass(2);
    delete BaseClassObjPtr;
}


int main(){
    std::cout<<"Main function start now."<<std::endl;
    BaseClassPresentation();

    return 0;
}

BaseClass.h :

#ifndef KEYWORDS_BASECLASS_H
#define KEYWORDS_BASECLASS_H


#include <iostream>


class BaseClass {
public:
    //    Так делать нельзя. 
    //
    //    static int Value2 = 10;
    static int Value2;
    int Value1 = 50;

    BaseClass() {
        std::cout << "Constructor BaseClass has been called" << std::endl;
    }

    // Конструктор тоже может быть перегружен!
    BaseClass(int a){
        std::cout << "Constructor BaseClass has been called with argument. this->Value1 now is equal " << a << std::endl;
        this->Value1 = a;
    }

    // Это и функции ниже являются ПРОТОТИПАМИ!
    static void StaticFunction();

    // Так делать нельзя, потому что типы аргументов, или количество аргументов должны отличаться
    // в перегруженых функциях, не только возвращаемый тип знеачения.
    // float OverloadedFunction(int a);

    int OverloadedFunction(int a);

    // void OverloadedFunction(int a);
    // Возвращаемый тип перегруженных функций может быть как одинаковый , так и различаться.
    int OverloadedFunction(int a, int b);

    float OverloadedFunction(double a, double b);

    //  Деструктор. Не имеет аргументов. Да и не нужны они ему, на самом деле.
    //  Вызывается при удалении объекта или при закрытии программы.
    //  Так же деструктор НЕ МОЖЕТ быть перегружен и вообще должен быть только один.
    //    ~BaseClass(int a){}

    ~BaseClass(){
        std::cout << "Delete anythig used by BaseClass class" <<std::endl;
    }
};


#endif //KEYWORDS_BASECLASS_H

BaseClass.cpp :

#include "BaseClass.h"



int BaseClass::Value2 = 5;

//Появляется ошибка - cannot declare member function <...> to have static linkage
//Мы не можем объявлять функции статическими, только определять. В данном случае мы как раз ОБЪЯВЛЯЕМ
//В свою очередь ОПРЕДЕЛЯЕМ эту функцию мы в самом теле класса, то есть в файле BaseClass.h
//static void BaseClass::StaticFunction(){              --- НЕ БУДЕТ РАБОТАТЬ. ПОТОМУ ЧТО.
void BaseClass::StaticFunction(){
    std::cout << "Call static function" <<std::endl;
    std::cout << "Static value of variable Value2 - " << Value2 << std::endl;
    Value2 = 10;
    std::cout << "Static value of variable Value2 after new value - " << Value2<< std::endl;
}

int BaseClass::OverloadedFunction(int a) {
    std::cout << "Overloaded function with one argument (int a). Argument value is - " << a << std::endl;
    return 1;
}

int BaseClass::OverloadedFunction(int a, int b) {
    std::cout << "Overloaded function with two integer arguments (int a, int b). Sum arguments - " << a+b << std::endl;
    return 1;
}

float BaseClass::OverloadedFunction(double a, double b) {
    std::cout << "Overloaded function with two double arguments (double a, double b). Division arguments - " << a/b << std::endl;
    return 1.0;
}

I already said above, but I will repeat in advance - why can't we delete an object by the name of the object, isn't it just a pointer to the object?
A big thank you to everyone who has contributed to this issue.

Answer 1

BaseClass BaseClassObj;
The object is created on the stack and will be destroyed (the pointer to the top of the stack is simply shifted in fact) when the scope (function) is exited, attempts to delete it through delete will lead to UB, i.e. it is impossible to say what will happen, and there is no need.