Data-driven flag setting in derived class constructor

Question

Say I have a base class with a flag inside of it which derived classes have to set:

struct Base
{
    bool flag;
    Base(bool flag):flag(flag) {}
};

I want to configure which derived classes set the flag to true/false in a data-driven way - i.e. I'd like to configure this from a header.

struct Derived1 : Base
{
    Derived1() : Base( expr ) {}
};

Where expr is something (don't know what yet) that is able to get the info from the header - tell whether Derived1 should make flag true or false. Ideally, I'd get an error if I make a new derived class but fail to specify the flag in the header, but this isn't mandatory. This way I can just modify a single central location to make changes.

What's the idiomatic approach for this?

@LuchianGrigore I guess _maaaayybe_ if you have the field declared on the derived and initialize it `constexpr`, you could read it with a trait emplying `declval()` - this is an extremely long shot though. — sehe, Feb 04 '13 at 12:25

Lightness Races in Orbit · Answer 1 · 2013-02-04T12:22:42.087

2

You could write:

struct Derived1 : Base
{
    Derived1() : Base(Concept<Derived1>::theFlag) {}
};

And your header could have the following:

template <typename T>
struct Concept
{};

template <>
struct Concept<Derived1>
{
   static const bool theFlag = true;
};

with the specialisation repeated for each type.

Is that what you meant? Compilation will fail when you didn't give a flag value for some DerivedN.

edited Feb 04 '13 at 12:22

answered Feb 04 '13 at 12:15

Lightness Races in Orbit

378,754
76
643
1,055

Perhaps it's a runtime parameter? – Gearoid Murphy Feb 04 '13 at 12:15
@Gearoid: The contents of headers cannot be decided at runtime. – Lightness Races in Orbit Feb 04 '13 at 12:16
@GearoidMurphy no. It's compile-time. @ Lightness yes, similar to this, but I'd like a more compact version. – Luchian Grigore Feb 04 '13 at 12:16
@LuchianGrigore: I'm not sure that I can beat this. C++ doesn't have any sort of native data interchange format. – Lightness Races in Orbit Feb 04 '13 at 12:17
Could the same effect be achieved by an enumerated constant? – Gearoid Murphy Feb 04 '13 at 12:18
@GearoidMurphy: I don't see how if we want to use the type directly. – Lightness Races in Orbit Feb 04 '13 at 12:19
you can remove Concept's default definition – BЈовић Feb 04 '13 at 12:23
If you do that, you can't use it for SFINAE. – Puppy Feb 04 '13 at 12:24
@LuchianGrigore You could use a macro to define specializations, then it's reasonably compact: https://ideone.com/tEldkC – jrok Feb 04 '13 at 13:37
@LightnessRacesinOrbit Done that. – jrok Feb 04 '13 at 13:50

Lightness Races in Orbit · Accepted Answer · 2013-02-04T12:26:22.573

2

An alternative version that uses a single function might be more compact:

struct Derived1 : Base
{
    Derived1() : Base(theFlag(this)) {}
};

Then in the header:

template <typename T>
bool theFlag(T*)
{
   if (typeid(T) == typeid(Derived1)) return true;
   if (typeid(T) == typeid(Derived2)) return false;
   if (typeid(T) == typeid(Derived3)) return true;

   throw std::runtime_error("No theFlag is given for this type");
}

If you are married to the compile-time check, the best you could do is to introduce a bit of duplication:

template <typename T>
bool theFlag(T*)
{
   static_assert(
      std::is_same<T, Derived1>::value ||
      std::is_same<T, Derived2>::value ||
      std::is_same<T, Derived3>::value,
      "No theFlag is given for this type"
   );

   if (typeid(T) == typeid(Derived1)) return true;
   if (typeid(T) == typeid(Derived2)) return false;
   if (typeid(T) == typeid(Derived3)) return true;
}

This basically relies on SFINAE - the compiler would not be able to find an overload for theFlag if you called it with an unsupported argument, essentially.

edited Feb 04 '13 at 12:26

answered Feb 04 '13 at 12:19

Lightness Races in Orbit

378,754
76
643
1,055

Hmmmm, this one looks nicer, yes. – Luchian Grigore Feb 04 '13 at 12:20
I'm not convinced that the `static_assert` is right. That is, I'm sure it's not. Perhaps someone can help me correct it before my initial 5 mins are up? :P – Lightness Races in Orbit Feb 04 '13 at 12:20
It's completely wrong. Either you perform the type dispatching at compiletime via template specialization, in which case you can static_assert, or the assert will always fail. – Puppy Feb 04 '13 at 12:21
@DeadMG: Yep -- I don't think that I can improve this any further without ending up back at the other answer. – Lightness Races in Orbit Feb 04 '13 at 12:22

score 2 · Answer 3 · answered Feb 04 '13 at 13:49

I'd write a trait class for flags and use a macro to define specializations:

#include <type_traits>

template<typename T>
struct FlagTrait {
    static_assert(std::is_void<T>::value, "No flag defined for this type.");
};

#define DEFINE_FLAG(Type, Val)               \
        template<>                           \
        struct FlagTrait<class Type>         \
            : std::integral_constant<bool, Val> {};

template<typename T>
constexpr bool getFlag(T) { return FlagTrait<T>::value; }

#define GET_FLAG getFlag(*this)

Now all we need to do for each new derived class is to add a line with class name and value of the flag:

DEFINE_FLAG(Derived1, true)
DEFINE_FLAG(Derived2, false)

Usage:

struct Base
{
    bool flag;
    Base(bool flag):flag(flag) {}
};

struct Derived1 : Base
{
    Derived1() : Base(GET_FLAG) {}
};

struct Derived2 : Base
{
     Derived2() : Base(GET_FLAG) {}
};

Gearoid Murphy · Answer 4 · 2013-02-04T14:45:51.267

1

Here's a pure compile-time solution:

struct Derived1 ;
struct Derived2 ;
template <typename Derived> struct Bootstrap
{
    bool init(Derived1 *) { return true ; }
    bool init(Derived2 *) { return false ; }
    Bootstrap():flag(init(static_cast<Derived *>(this))){}
    bool flag ;
};
struct Derived1: public Bootstrap <Derived1> {};
struct Derived2: public Bootstrap <Derived2> {};
int main()
{
    Derived1 d1 ;
    Derived2 d2 ;
    std::cout<<d1.flag<<" "<<d2.flag<<std::endl ;
    return 0 ;
}

EDIT

As pointed out by 'Lightness Races in Orbit', static_cast during ctor process can cause Undefined Behabiour (UB). Here's an updated implementation which negates the need for the static_cast operator:

#include <iostream>
struct Derived1 ;
struct Derived2 ;
namespace BootstrapDetail
{
    template <typename Identifier> bool init();
    template <> bool init <Derived1>() { return true ; }
    template <> bool init <Derived2>() { return false ; }
}
template <typename Derived> struct Bootstrap
{
    Bootstrap(): flag(BootstrapDetail::init<Derived>()) {}
    bool flag ;
};
struct Derived1: public Bootstrap <Derived1> {};
struct Derived2: public Bootstrap <Derived2> {};
int main()
{
    Derived1 d1 ;
    Derived2 d2 ;
    std::cout<<d1.flag<<" "<<d2.flag<<std::endl ;
    return 0 ;
}

edited Feb 04 '13 at 14:45

answered Feb 04 '13 at 12:29

Gearoid Murphy

11,834
17
68
86

`struct Derived1*` and `struct Derived2*` *cough* – Xeo Feb 04 '13 at 12:31
Does that convention need to be followed in C++? – Gearoid Murphy Feb 04 '13 at 12:33
3

No, but it keeps the code shorter. :) It's effectively an inline declaration, meaning you don't need the `struct Derived1;` and `struct Derived2;` at the top anymore. – Xeo Feb 04 '13 at 12:36
Awesome, I did not know that. Does it work for 'class' structures too? – Gearoid Murphy Feb 04 '13 at 12:38
Is `static_cast(this)` valid in a base ctor-initialiser? – Lightness Races in Orbit Feb 04 '13 at 12:40
I believe so, asfaik only dynamic_cast operations are subject to ctor restrictions. – Gearoid Murphy Feb 04 '13 at 12:42
2

@GearoidMurphy: No some static casts are restricted during initialisation too (see 12.7/3, for example). Though I can't find any wording to prohibit your code. – Lightness Races in Orbit Feb 04 '13 at 12:52
http://stackoverflow.com/questions/14687396/is-it-legal-to-cast-this-to-derived-in-the-base-ctor-initialiser – Lightness Races in Orbit Feb 04 '13 at 13:45
@LightnessRacesinOrbit, good point (good question too), I guess since the pointer is not dereferenced the potential for undefined behaviour is eliminated or at least reduced. – Gearoid Murphy Feb 04 '13 at 14:32
@GearoidMurphy: Arguably just _having_ the casted pointer is already UB :) – Lightness Races in Orbit Feb 04 '13 at 14:35

Data-driven flag setting in derived class constructor

4 Answers4

Linked