C++ How to initialize members with hidden default constructors?

Question

I have a class with a hidden default constructor to force the use of a constructor taking parameters. Another class is using 2 instances of the class:

typedef struct { ... } BAZ;

class Foo {
  private:
    Foo(void) {}

  public:
    Foo(BAZ a) { ... }
};

class Bar {
  private:
    Foo foo1;
    Foo foo2;

    Bar(void) {}

  public:
    Bar(BAZ a, BAZ b) : foo1(a), foo2(b) { ... }
};

The most obvious is that the declaration of the variables foo1 and foo2 will call the default Foo constructor, but since it is private it can't and will give a compiler error.

Is there a way to prevent it from trying the default Foo constructor and just wait for the Bar constructor to initialise them instead?

I want to avoid the use of the new keyword (which would solve the whole problem).

EDIT:
It seems like people have a hard time to understand the question and dilemma. I will try to explain:

I want to force the use of a Foo(BAZ) constructor meaning that any attempt to use the Foo(void) constructor will generate an error.

To hide the default constructor it is declared as a private member. If someone try to use the default constructor Foo() it will give an intentional error.

To not declare the default constructor and only declare Foo(BAZ) is not preventing the compiler to create a public default constructor. It gives no error if I declare it Foo(). So far it works fine and as intended.

The second class Bar have two instances of Foo but when Bar is instanced these Foo members will be called with the default (hidden) constructor and generate an error. Then in the Bar constructor, these two instances will be initialized with the correct public constructor Bar(BAZ a, BAZ b) : foo1(a), foo2(b). This is what I want.

Is there a way to prevent it from calling Foo default constructor when Bar is initialized, so the Bar constructor can use the correct Foo constructor?

The new solution works because the default constructor is never called:

BAZ a = {...}
Foo *foo1 = new Foo(a);

I hope this makes it more clear.

EDIT2: SOLVED The error wasn't in the hidden Foo constructor, it was the hidden Bar constructor trying to use the hidden default Foo constructors.

Bar(void) : Foo(BAZ{}), Foo(BAZ{}) {}

Solved it.

EDIT3:
The real problem seems to have been in the development tool. After restart and manually clearing the cache it worked as the C++14 standard intended.

Answer 1

the declaration of the variables foo1 and foo2 will call the default Foo constructor

No. Declaring these member variables only says that they are members. It doesn't say anything about how they will be constructed. That's the job of the constructor(s) of the class that uses them.

Bar(BAZ a, BAZ b) : foo1(a), foo2(b) { ... }

Fine so far: this constructor constructs the foo1 and foo2 members using the constructor Foo(Baz).

Bar(void) {}

This is the problem: it attempts to construct the foo1 and foo2 members with the default constructor for Foo. Since that constructor is not accessible (that's the correct term; it is not hidden), you get an error. There are at least three solutions:

1:

Bar() : foo1(Baz()), foo2(Baz()) {}

This uses the constructor that takes Baz.

2:

Bar() = delete;

This makes the default constructor for Bar not exist, so it doesn't try to use the default constructor for Foo.

3:

Just don't do it. If you don't write a default constructor but you do write another one, the compiler won't generate a default constructor.

Answer 2

Don't hide constructors. Don't declare them in the first place.

typedef struct { ... } BAZ;

class Foo {
  public:
    Foo(BAZ a) { ... }
};

class Bar {
  private:
    Foo foo1;
    Foo foo2;

  public:
    Bar(BAZ a, BAZ b) : foo1(a), foo2(b) { ... }
};