Templates and preprocessing in C++

Question

How can someone make this code compile:

#include <iostream>
using namespace std;

enum E { A, B};

template< E x>
class C {
public:
    #if( x == A)
        static void foo() {
            cout << "A";
        }
    #elif( x == B)
        static void goo() {
            cout << "B";
        }
    #endif
};


int main() {
    C< A>::foo();
    C< B>::goo();

    return 0;
}

error: ‘goo’ is not a member of ‘C<(E)1u>’

I have two big classes which differs only a few lines, so I wanted to make enum template. The problem is that this lines have using keyword in them, so I don't know what to put there.

Is there some correct way to do it?

PS> I'm have to use C++03.

EDIT: A little clarification. I know about template<> construction, but I don't wanted to use it because this way I got a lot of code duplication. Maybe I can somehow make partial "template instanciation" (if this is correct term for template<>)?

Suppose I have two classes (and I will not have more):

class A {
public:
//…a lot of code…
//few lines that differs in A and B
}

class B {
//…the same mass of code…
//few lines that differs in A and B
}

So I decided to make template on enum:

enum E { A, B}
template< E>
class C{
//…common code…
}

Now I don't know what to do with this few lines that differs in A and B. I know that common way is to make template instanciation, but then I'll get exactly what I had with classes A and B.

From the OOP point I should use common Base for A and B. But the problem is that A and B is already the same. They differs only with line:

using CanStoreKeyValue< QString, Request>::set;
using CanStoreKeyValue< QString, Response>::set;

where Response and Request are typedefs. Moreover, in my code A and B are childs of the same templated abstract class. And of course they inherit it with different template param. This somehow brokes using of template enum — compiler just can't see that some virtual methods a no longer pure. So… that's why I'm asking what I'm asking. I thought that preprocessor could interact with template engine with #if-directives (on the end, they both are compile time processes).

Preprocessing happens before anything else. The preprocessor directives (beginning with `#`) have no idea tha `A`, `B` and `x` even exist. — Joseph Mansfield, Jul 23 '14 at 16:50
I don't understand what you are trying to do. Why not have two classes, one with foo and one with goo? — Neil Kirk, Jul 23 '14 at 16:50
Are you trying to get a compile time error if the method is not compatible with the parameter or are you trying to do some sort of compile time dispatching? — shuttle87, Jul 23 '14 at 16:53
Your preprocessor directives (any starting with #) remove the definition of `goo()` before the compiler even sees it. — Logicrat, Jul 23 '14 at 16:54
Yes, first of all I'm trying to understand if I can use preprocessor directives with template engine. Thank you guys, that you pointed that I can't do this in C++. And secondly, I trying to find the way to have `foo` in `C` and `goo` in `C` **without** using of the template instanciation (I mean, `template<>`) — this is because in this case I will have a lot of duplicate code. — Valentin T., Jul 23 '14 at 20:11
@ValentinT. why you do not make that Request/Response type a template parameter instead of A, B? — Slava, Jul 23 '14 at 21:06
I thought that I can't use typedefs as template parameter, so I decided to use `enum IO {In, Out}` as code for them. — Valentin T., Jul 23 '14 at 21:13
@Slava, in fact I can. Thank you for your proposal, I'll use `Req` and `Resp` in change of `enum`. — Valentin T., Jul 23 '14 at 21:53

Slava · Answer 1 · 2014-07-23T21:10:19.467

5

You cannot use preprocessor to achieve what you are trying to do. What you need is a template specialization:

enum E { A, B};

template< E x>
class C;

template <>
class C<A> {
public:
    static void foo() {
        cout << "A";
    }
};

template <>
class C<B> {
public:
    static void goo() {
        cout << "B";
    }
};

Your updated problem still can be resolved by template specialization:

enum E { A, B };

template< E x >
struct CanStoreKeyValueHelper;

template<>
struct CanStoreKeyValueHelper<A> {
    typedef CanStoreKeyValue< QString, Request>::set type;
};

template<>
struct CanStoreKeyValueHelper<B> {
    typedef CanStoreKeyValue< QString, Response>::set type;
};

template< E x>
class SuperPuperBigClass {
public:
    typedef typename CanStoreKeyValueHelper<x>::type set;
    ...
};

But it is not clear why you do not make it as simple as:

template<class T>
class SuperPuperBigClass {
public:
    typedef typename CanStoreKeyValue<QString, T>::set set;
};

and instantiate it with Request and Response type

edited Jul 23 '14 at 21:10

answered Jul 23 '14 at 16:54

Slava

43,454
1
47
90

Yes, I know that, but is there is some way in C++ to have `foo` in `C` and `goo` in `C` without using of "template instanciating" (I don't know, is it correct term for `template<>`)? – Valentin T. Jul 23 '14 at 20:06
I don't want to use `template<>` construction because this way I will have a lot of code duplication. – Valentin T. Jul 23 '14 at 20:14
@ValentinT.: Move the duplicate code into a shared base class. Alternatively, one could use `std::enable_if`, but that can be complex. – Mooing Duck Jul 23 '14 at 20:44
I have two classes inherits from the same templated abstract class with different template arguments. They already are inherited from the same base and differs with some `using` lines and pure virtuals implementation. And compiler somehow can't see that they implement the abstract base. So, I just wanted the construction analog for preprocessor `#if` construction, but for template. And I have to use C++03, so I believe `std::enable_if` is not my case. – Valentin T. Jul 23 '14 at 20:58

score 2 · Accepted Answer · edited May 23 '17 at 11:50

2

If you don't want specialization, I suppose constraining the functions with SFINAE is an option (Live at coliru):

template <E x>
class C {
public:
    template <E y = x>
    static typename std::enable_if<y == A>::type foo() {
        cout << "A";
    }

    template <E y = x>
    static typename std::enable_if<y == B>::type goo() {
        cout << "B";
    }
};

But if code duplication is your only issue, use specialization and put the common code in a base class (Live at Coliru), it's a bit cleaner:

class C_base {};

template <E x>
class C : public C_base {};

template <>
class C<A> : public C_base {
public:
    static void foo() {
        cout << "A";
    }
};

template <>
class C<B> : public C_base {
public:
    static void goo() {
        cout << "B";
    }
};

edited May 23 '17 at 11:50

Community

1
1

answered Jul 23 '14 at 20:41

Casey

41,449
7
95
125

thanks for the answer! Isn't std::enable_if is the C++11 construction? I didn't knew about SFINAE. – Valentin T. Jul 23 '14 at 21:03
@ValentinT. Woops yes - didn't notice the C++03 tag. Will add the canonical implementation to the answer. – Casey Jul 23 '14 at 21:04
I find this variant of the `enable_if` as easier on the eyes, when it works: http://coliru.stacked-crooked.com/a/d0d77cef8f219d21 – Mooing Duck Jul 23 '14 at 22:00
Thank you, @MooingDuck, I think your answer was the most closest to the topic problem. – Valentin T. Jul 23 '14 at 22:23
@ValentinT.: I just rewrote the code in this answer a different way. If what I wrote was correct, then Casey's answer is more correct. – Mooing Duck Jul 23 '14 at 22:24
@MooingDuck, Oh! I just confused you with @Casey! – Valentin T. Jul 23 '14 at 22:38

Templates and preprocessing in C++

2 Answers2