Question

I have a base class that is a template that looks like this:

template <typename T>
class Foo
{
public:
    T bar;
};

What I’d like to do is introduce a template argument that can be used to control the access mode of the member bar.

Something like this:

template <typename T,bool publicBar=true>
class Foo
{

public: 
    // If publicBar is false, insert protected: here
    T bar;
};

Is this possible?

Thanks.

Edit:
Many asked so, for those interesting in why I’m doing this, here’s my real code!

    // Class used for automatic setter/getter generation.
template <typename T,publicSetter=true>
class Property
{
public:
    Property(){}
    Property(T value):mObject(object){}
    T operator()()const
    {
        return mObject;
    }
public: // This is where I want the protected:
    virtual void operator()(T newObject)
    {
        this->mObject = newObject;
    }
private:
    T mObject;
};

Answer 1

This can be done using partial template specialization:

template <typename T,bool publicBar>
class Foo
{
};

template <typename T>
class Foo<T,true>
{
public: 
    T bar;
};

template <typename T>
class Foo<T,false>
{
protected: 
    T bar;
};

The only gotcha here is that you would need to replicate the entire class for each specialization… UNLESS you wanted to make it on top of a base class, e.g.:

template <typename T>
class FooBase
{
    //the goods go here
};

template <typename T,bool publicBar>
class Foo : public FooBase<T>
{
};

template <typename T>
class Foo<T,true> : public FooBase<T>
{
public: 
    T bar;
};

template <typename T>
class Foo<T,false> : public FooBase<T>
{
protected: 
    T bar;
};