In the following code:

template <class COORD>
class Foo
{
public:

    void setCoordinate( const COORD& coord ) { m_Coordinate = coord; }
    const COORD& getCoordinate() const { return m_Coordinate; }

    /* ... other methods ... */

private:

    COORD m_Coordinate;
    
    /* ... other data ... */
};

If I were to instantiate the class with the following code:

Foo<void> foo;

I would be forming a reference to "void", which would throw a compiler error.

Is there a way to completely omit the methods "setCoordinate" and "getCoordinate" as well as the data member "m_Coordinate" in the specific case where the template parameter COORD is void?

The class "Foo" still works without those methods in place, it's just more limited.

Oh you can specialize entire classes as well? Wow, how did I miss that...

So does this mean I'm forced to re-write the entire class specific to match a void template parameter? The class in question isn't exactly small, and the only thing that changes is omitting those two methods. That's a lot of redundant code.

Thanks!

Sorry, but another question arose. Say I wish to specialise single methods in the class for specific COORD arguments.

struct Vector2D
{
    Vector2D( int x, int y ) : x(x), y(y) {}
    int x;
    int y;
};

template <class COORD>
class Foo
{
public:
    void print( const COORD& coord );
};

template <class COORD>
void Foo<COORD>::print( const COORD& coord )
{
    std::cout << "Can't print - not specialised" << std::endl;
}

template <>
void Foo<Vector2D>::print( const Vector2D& coord )
{
    std::cout << "2D coordinates: " << coord.x << "," << coord.y << std::endl;
}

int main()
{
    Foo<int>().print(6);
    Foo<Vector2D>().print(Vector2D(3,5));
    return 0;
}

However, I'd like the user to have the ability to use their own Vector2D class - he could call it "Vec2" or something else. Obviously I can't see into the future, so I can't specialise a method beforehand.

With the assumption that every Vector2D class thrown at it should have public data members named "x" and "y", how can I solve this?

Ah, what I meant was that there could be completely other types as well which may or may not have "x" and "y", such as 1-dimensional types (which won't have "x" and "y"), or 3-dimensional types (which would have "x","y","z"), but would still count as coordinates, and require a specialised function to be dealt with.