Why my compiler does not work as expected?

Question

I tried this code on multiply online compilers and it work well but when I try it on my there are problems(well not exactly errors, but it not working as expected).

The destructor is not called for both static and gloabl objects. And if I put function create behind main then after it call constructor for objects in create, it does not doing anything afterwards, does not calling any destructor and does not even print message that are after function create.

I'm using Microsoft Visual Studio Community 2017 version 15.9.17 if it is of any use.

So is there any solution to these or I need to install Visual Studio all over again?

// Expected

Object 1    constructor runs    (global before main)

MAIN FUNCTION: EXECUTION BEGINS  
Object 2    constructor runs    (local automatic in main)  
Object 3    constructor runs    (local static in main)

CREATE FUNCTIONS: EXECUTION BEGINS   
Object 5    constructor runs    (local automatic in create)             
Object 6    constructor runs    (local static in create)   
Object 7    constructor runs    (local automatic in create)

CREATE FUNCTION: EXECUTION ENDS  
Object 7    destructor runs (local automatic in create)  
Object 5    destructor runs (local automatic in create)

MAIN FUNCTION: EXECUTION RESUMES  
Object 4    constructor runs    (local automatic in main)  

MAIN FUNCTION: EXECUTION ENDS  
Object 4    destructor runs (local automatic in main)  
Object 2    destructor runs (local automatic in main)  
  
Object 6    destructor runs (local static in create)  
Object 3    destructor runs (local static in main)  
  
Object 1    destructor runs (global before main)

// Acctual

Object 1    constructor runs    (global before main)  
  
MAIN FUNCTION: EXECUTION BEGINS  
Object 2    constructor runs    (local automatic in main)  
Object 3    constructor runs    (local static in main)  
  
CREATE FUNCTIONS: EXECUTION BEGINS  
Object 5    constructor runs    (local automatic in create)  
Object 6    constructor runs    (local static in create)  
Object 7    constructor runs    (local automatic in create)  
  
CREATE FUNCTION: EXECUTION ENDS  
Object 7    destructor runs (local automatic in create)  
Object 5    destructor runs (local automatic in create)  
  
MAIN FUNCTION: EXECUTION RESUMES  
Object 4    constructor runs    (local automatic in main)  
  
MAIN FUNCTION: EXECUTION ENDS  
Object 4    destructor runs (local automatic in main)  
Object 2    destructor runs (local automatic in main)

Acctual if I put function create behind main

Object 1    constructor runs    (global before main)  
  
MAIN FUNCTION: EXECUTION BEGINS  
Object 2    constructor runs    (local automatic in main)  
Object 3    constructor runs    (local static in main)  
  
CREATE FUNCTIONS: EXECUTION BEGINS  
Object 5    constructor runs    (local automatic in create)  
Object 6    constructor runs    (local static in create)  
Object 7    constructor runs    (local automatic in create)  
  
CREATE FUNCTION: EXECUTION ENDS

#include <iostream>
using std::cout;
using std::endl;

class CreateAndDestroy {
public:
    CreateAndDestroy(int, const char*); // constructor
    ~CreateAndDestroy();            // destructor

private:
    int objectID;
    const char* message;
};  // end class CreateAndDestroy

// constructor
CreateAndDestroy::CreateAndDestroy(int objectNumber, const char* messagePtr) {
    objectID = objectNumber;
    message = messagePtr;

    cout << "Object " << objectID << "  constructor runs    " << message << endl;
}   // end CreateAndDestroy constructor

// destructor
CreateAndDestroy::~CreateAndDestroy() {
    cout << (objectID == 1 || objectID == 6 ? "\n" : "");

    cout << "Object " << objectID << "  destructor runs " << message << endl;
}   // end ~CreateAndDestroy destructor

void create(void);  // prototype

// functions to create objects
void create(void) {
    cout << "\nCREATE FUNCTIONS: EXECUTION BEGINS" << endl;
    CreateAndDestroy fifth(5, "(local automatic in create)");
    static CreateAndDestroy sixth(6, "(local static in create)");
    CreateAndDestroy seventh(7, "(local automatic in create)");
    cout << "\nCREATE FUNCTION: EXECUTION ENDS" << endl;
}   // end function create

    // global object
CreateAndDestroy first(1, "(global before main)");

int main(int argc, char *argv) {
    cout << "\nMAIN FUNCTION: EXECUTION BEGINS" << endl;
    CreateAndDestroy second(2, "(local automatic in main)");
    static CreateAndDestroy third(3, "(local static in main)");
    create();   // call function to create objects
    cout << "\nMAIN FUNCTION: EXECUTION RESUMES" << endl;
    CreateAndDestroy fourth(4, "(local automatic in main)");
    cout << "\nMAIN FUNCTION: EXECUTION ENDS" << endl;

    return 0;
}   // end main ```

When - in your opinion - would you expect, the destructor of the static instance should be called? I think never is quite alright. Same for the global one. After leaving main(), it would also be a question about the order of execution of such destructors. I remember back in the MFC days (theApp... ), how error prone global variables could become. Also, using static variables in functions is disadviced, because you cannot recreate a defined state (e.g. for testing). — BitTickler, Feb 05 '21 at 09:10
@BitTickler The static initialisation (and finalisation) order is tricky, but it’s well-defined within a single translation unit. — Furthermore, your advice regarding local static variables is *sometimes* reasonable, but there are good, recommended uses for local statics, which override testability. — Konrad Rudolph, Feb 05 '21 at 09:16
Statics at file scope (in one translation unit) are constructed in order of definition. Statics in a function block (or a block within a function) are constructed when their containing block is first entered - which can apply a different order relative to statics at file scope in the same compilation unit (i.e. not necessarily in the order that their definition appears in the file) - which I suspect is different than you are expecting. Construction order of statics in different compilation units is unspecified. — Peter, Feb 05 '21 at 09:16
@BitTickler: Your assumptions are wrong. Destructors of static instances definitely should run after `main` returns, e.g. to clean up temporary files. — MSalters, Feb 05 '21 at 09:16
@largest_prime_is_463035818 Thanks I added expected and both actual output in question. — Alex4, Feb 05 '21 at 09:25

score 1 · Answer 1 · answered Feb 05 '21 at 11:48

1

Check in the debugger (or by saving some logs on the disk instead of using std::cout) if the destructors are actually not called. Perhaps this is "only" std::cout for which the destructor is called before the destructors of the global and static objects defined in your compilation unit.

See: Using cout in destructors of static objects

answered Feb 05 '21 at 11:48

zkoza

2,644
3
16
24

Good answer! It makes my point, that the lack of a guarantee, that any facility is still operational after exiting main (here, std::cout) should be reason enough, not to have any resource state (e.g. file handles, files to cleanup, ...) in global or module global variables. And given, that all memory pages are removed and returned to the system (and on most OS also file handles etc being closed automatically), tidying up memory is also not a concern. As an aside, a practice, which relies upon cleanup after main also turns leak detection into a pathological case. – BitTickler Feb 05 '21 at 14:22
@BitTickler — in any source file that `#include`s the header `` the standard streams (`std::cin`, `std::cout`, `std::cerr`, and `std::clog`, and their `std::wxxx` counterparts) are required to be constructed before any global or static objects defined in that source file. So the streams are all valid. And since global and static objects are destroyed in reverse order of their construction, the streams remain valid until after the destructors for those objects. (That’s a bit simplified, but it’s correct for this example.) – Pete Becker Feb 05 '21 at 19:27

score 0 · Answer 2 · answered Feb 08 '21 at 03:26

The global object is constructed before the main function is executed, and the local static object is constructed before the execution of the function body. The local static object is destructed earlier than the global object. They are all after the main function.

I tested the code and it worked fine. But I found this problem under command line compilation. So this should be because the console disappeared before it was displayed. I suggest that you could add the following code.

int main(int argc, char* argv) {
    cout << "\nMAIN FUNCTION: EXECUTION BEGINS" << endl;
    CreateAndDestroy second(2, "(local automatic in main)");
    static CreateAndDestroy third(3, "(local static in main)");
    create(); // call function to create objects
    cout << "\nMAIN FUNCTION: EXECUTION RESUMES" << endl;
    CreateAndDestroy fourth(4, "(local automatic in main)");
    cout << "\nMAIN FUNCTION: EXECUTION ENDS" << endl;
    getchar();
    system("pause");
    return 0;
} // end main ``

If it still doesn't work, I suggest that you could using Debug to trace the code.

Why my compiler does not work as expected?

2 Answers2