Empty default constructor, copy constructor and copy assignment: Why with a singleton the member variables are not random?

Question

I am studying constructor, copy constructors and copy assignment a while and I read a fair amount of contents mainly from here as In which situations is the C++ copy constructor called? and What is The Rule of Three? and others, but I still no deeply understanding their exactly behavior. I am performing some tests with the class Boo and Foo bellow and their results are not the ones that I was expecting. In the class Boo I explictly declared its default constructor, copy constructor and copy assingment, and I defined them to do nothing. From this I was expecting that the objects from this class would have member variables with random values, what was indeed observed. Nevertheless, this behavior was not seen with the objects from the class Foo. The only difference between these classes are that the later is a singleton, but its default constructor, copy constructor and copy assignment still explicit declared and defined to do nothing. From this I state my question: Why the values of the member variables of objects from class Foo are not randomly initialized, but always has de same value of "0" and " "?

#include <iostream>

class Boo {
    private:
        int x;
        char y;

    public:
        int getInt() { return x; }
        char getChar() { return y; }
        Boo () { std::cout << "Boo default constructor\n"; }
        Boo ( const Boo& other ) { std::cout << "Boo copy constructor\n"; }
        Boo& operator= ( const Boo& other) { std::cout << "Boo copy assinment\n";
                                            return *this;}

};

class Foo {
    private:
        int x;
        char y;
        static Foo *instance;

    protected:
        Foo() { std::cout << "Foo default constructor\n"; }
        Foo ( const Foo& other ) { std::cout << "Foo copy constructor\n"; }
        Foo& operator=( const Foo& other) { std::cout << "Foo copy assignment\n"; }

    public:
        static Foo & uniqueInst();
        int getInt() { return x; }
        char getChar() { return y; }
};

Foo *Foo::instance = 0;

Foo & Foo::uniqueInst(){
    if(!instance) instance = new Foo();
    return *instance;
};

int main(){
Boo b1; // default constructor
Boo b2; // default constructor
Boo b3 = b1; // copy constructor

b2 = b1;

std::cout << b1.getInt() << std::endl; // Random values since the constructor does nothing
std::cout << b1.getChar() << std::endl;

std::cout << b2.getInt() << std::endl; // Random values since the copy assignment does nothing
std::cout << b2.getChar() << std::endl;

std::cout << b3.getInt() << std::endl; // Random values since the copy constructor does nothing
std::cout << b3.getChar() << std::endl;


Foo *foo;
foo = &Foo::uniqueInst(); // defaulf construtor

std::cout << foo << std::endl;
std::cout << foo->getInt() << std::endl; // Why not random values?
std::cout << foo->getChar() << std::endl;

};