current community

your communities

more stack exchange communities

Stack Exchange
tour help
stack overflow careers
Take the 2-minute tour ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 2 down vote favorite

Consequently to a previous question about const/non-const with ternary operator, is the following test function ok regarding to the C++11 standard :

template<bool UseConst> class MyClass
{
    public:
        constexpr bool test()
        {
             return (UseConst) ? (_constvar) : (_var);
        }

    protected:
        int _var;
        static const int _constvar;
}

The whole problem, is that _constvar is const, and _var is non-const. I would have to access these 2 data depending on the template parameter through the same function, and I would like to have a compile-time function when I use const.

Do the test() function satisfy my requirements ?

share|improve this question
    
Why not simply specialize on UseConst and go from there? –  Xeo Sep 26 '12 at 12:56
    
Specialize what ? The class or the function ? For the class, I have a large set of functions and it would be far more easier and concise to retrieve the const or the non-const through a single function like here. To specialize the function, I do not see how to do that... –  Vincent Sep 26 '12 at 13:01
    
@Vincent : Non-template member functions inside of class templates are actually just function templates and can be specialized as such without specializing the entire class. See e.g. the code in this answer. –  ildjarn Sep 26 '12 at 18:49
    
Shouldn't test() return an int? And what is the problem in making this test function constexpr? It compiles for me. –  KennyTM Sep 27 '12 at 17:55

1 Answer 1

up vote 0 down vote accepted

You could use SFINAE in order to "specialize" your test function. In other words, you could do something like the following:

template<bool true_false>
struct true_type
{
    static char value;
};

template<>
struct true_type<false>
{
    static char value[2];
};

template<bool UseConst> class MyClass
{
    private:
        constexpr int pre_test(const char arg) { return _constvar; }
        int pre_test(char (&)[2]) const { return _var; }

    public:
        constexpr int test()
        {
             return pre_test(true_type<UseConst>::value);
        }

    protected:
        int _var;
        static const int _constvar;
};

Now, when you call MyClass::test, if UseConst is false, test will degrade to a run-time function, but when UseConst is true, you will get a compile-time function.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.