Declare a member according to used constructor - c++

Question

struct foo
{
foo(int something) : m_something{ something } {}
foo() { }
private:
int m_something{};
};
struct bar
{
bar(foo& f)
:
m_foo{ f }
{ }
bar(int something)
:
m_default{ something } ,
m_foo{ m_default }
{
}
private:
foo m_default;
foo& m_foo;
};
bar class can be constructed by reference of foo or it can initialize the foo itself. I want to get rid of unnecessary initialization cost of m_default in case which bar is constructed by reference of foo. I know it can be solved by using pointers but I want to stay within stack.
Is it possible ?
Ted Lyngmo's answer just worked flawlessly. I am sharing full code :
#include <iostream>
struct foo;
struct foo_own;
// only holds a reference
struct foo_ref {
foo_ref(foo& fr) : m_foo(fr) {
std::cout << "foo_ref constructor is called\n";
}
virtual ~foo_ref() = default;
operator bool() { return false; }
operator foo&() { return m_foo; }
foo& operator*() { return m_foo; }
private:
foo& m_foo;
};
struct foo
{
foo(int something) : m_something{ something } {}
foo() { }
private:
int m_something{};
};
// owning a foo
struct foo_own : public foo_ref {
foo_own(int something) : foo_ref(m_default), m_default(something) {
std::cout << "foo_own constructor is called\n";
}
private:
foo m_default;
};
struct bar
{
bar(const foo_ref& f)
:
m_foo{ f }
{ }
bar(const foo_own& f)
:
m_foo{ f }
{ }
private:
const foo_ref& m_foo;
};
int main(int, char**) {
foo foo_l;
bar b{foo_l};
bar b2{15};
return 0;
}
and the output is
foo_ref constructor is called foo_ref constructor is called foo_own
constructor is called

Answer 1

You could divide it into two types of foo wrappers:
// only holds a reference
struct foo_ref {
foo_ref(foo& fr) : m_foo(fr) {}
virtual ~foo_ref() = default;
operator foo&() { return m_foo; }
foo& operator*() { return m_foo; }
private:
foo& m_foo;
};
// owning a foo
struct foo_own : public foo_ref {
foo_own(int something) : foo_ref(m_default), m_default(something) {}
private:
foo m_default;
};
To avoid future slicing and have a way of creating your foo_refs and foo_owns that looks very similar, you could add a couple of helper functions:
auto make_foo_wrapper_ptr(foo& f) {
return std::make_unique<foo_ref>(f);
}
auto make_foo_wrapper_ptr(int v) {
return std::make_unique<foo_own>(v);
}

Answer 2

You can use an std::variant that can either be empty (meaning hold an std::monostate) or hold a foo. m_foo should then be made to refer to the passed foo& in the first constructor, or the foo held by the variant in the second constructor.
In both cases, the rest of bar's code should just use m_foo regardless of how the instance was constructed, since either way it refers to a valid foo object.
This requires C++17 support.
#include <variant>
struct bar
{
// We do not initialize m_foo_var here so that it's going to be
// default constructed as empty.
bar(foo& f)
: m_foo(f)
{}
bar(int something)
: m_foo_var(something)
, m_foo(std::get<foo>(m_foo_var))
{}
private:
std::variant<std::monostate, foo> m_foo_var;
foo& m_foo;
};
Note that this gets rid of the initialization overhead, but not of the memory overhead. m_foo_var will still occupy sizeof(foo) bytes.