1

I have a function template declared in an header file. This function is an archiver which is supposed to support several other types (classes) implemented through the project. The idea is to have a base template declaration which each class then specialises to its own types.

// Archiver.h
template <class T> void archive(Archiver & archiver, const T & obj);

This method does not have an implementation. Now I create a class (say, Header) and I want it to be archivable. As such, it is my intent to specialise the method. Here's what I have now:

// Header.h
extern template void archive(Archiver & archiver, const Header & obj);

I declare the function as extern because I implement it in the .cpp file

// Header.cpp
template <> void archive(Archiver & archiver, const Header & obj)
{
 // Code here
}

This gives specialization after instantiation. I've tried other combinations as well:

  1. Implementing directly in the header file, as is usually recommended for templates: I get "multiple definition"
  2. Implementation in the .cpp file without a declaration on the header: I get undefined reference when calling the method from another compilation unit

So what is the correct of implementing this?

Edit:

Initially I decided to go with templates because of the inverse process, unarchiving. Basically I could write unarchive<Header>() instead of unarchive_header() which seemed more appropriate.

I believe I should also mention that I'm compiling this using Android Studio and the Gradle build system, which is why I'm using gcc and not g++. I also gave gcc the following compiler flags:

-std=gnu++11 -fexceptions -fpermissive -lstdc++

-fpermissive was an act of despair.

bogdan
  • 9,229
  • 2
  • 33
  • 48
André Fratelli
  • 5,920
  • 7
  • 46
  • 87

3 Answers3

5

Just don't use templates:

// Header.h
void archive(Archiver & archiver, const Header & obj);

and

// Header.cpp
void archive(Archiver & archiver, const Header & obj)
{
 // Code here
}

Much simpler that way. Simply make an unqualified call to archive() and make sure this overload is declared in the same namespace as Header and let ADL do its magic.

Barry
  • 286,269
  • 29
  • 621
  • 977
  • I believe at the time I decided to go with templates because of the inverse process, unarchiving. I could write `unarchive
    ()`, instead of `unarchive_header()`. I think the first form is more convenient
     – André Fratelli Oct 21 '15 at 18:24
  • @AndréFratelli Why do you think you have to write `unarchive_header()`? Just write `unarchive()`. – Barry Oct 22 '15 at 14:02
  • Because `Header` is not the only unarchivable class and this function wouldn't be overridable because it does not get any parameters – André Fratelli Oct 22 '15 at 14:09
2

Why use a function template?

You said:

The idea is to have a base template declaration which each class then specialises to its own types.

If a function template does not have a default implementation, it is pointless to have one at all. You can just use:

extern void archive(Archiver & archiver, const Header & obj);

when you need it.

If you must use a function template

The line

extern template void archive(Archiver & archiver, const Header & obj);

is not right. It needs to be:

template <> void archive<Header>(Archiver & archiver, const Header & obj);

The implementation needs to use the same signature.

template <> void archive<Header>(Archiver & archiver, const Header & obj)
{
}

Update, in response to OP's comment

I tried the following to simulate your situation.

socc.h:

#pragma once

struct Archiver {};

template <class T> void archive(Archiver & archiver, const T & obj);

struct Header {};

template <> void archive<Header>(Archiver & archiver, const Header & obj);

socc.cc:

#include <iostream>
#include <string>

#include "socc.h"

int main()
{
   Archiver ar;
   Header obj;
   archive(ar, obj);
}

socc-2.cc:

#include "socc.h"

template <> void archive<Header>(Archiver & archiver, const Header & obj)
{
}

Command to build:

g++ -std=c++11 -Wall    socc.cc  socc-2.cc -o socc

The program was built successfully.

R Sahu
  • 204,454
  • 14
  • 159
  • 270
  • That second approach gives "undefined reference" at the calling point. I'm still looking into not using templates. – André Fratelli Oct 21 '15 at 18:22
  • @AndréFratelli, See Update. – R Sahu Oct 21 '15 at 18:29
  • Could you make it work with gcc instead? I've tried adding the `-lstdc++` compiler flag. I didn't mention it initially (it didn't seem relevant) but I'm using Gradle to build for Android. I'm also looking into how to switch to g++ with gradle – André Fratelli Oct 21 '15 at 18:41
  • @AndréFratelli, It doesn't make sense to compile C++ code with `gcc`. You should figure out how to use `g++ `in your development tool. I am not familiar with it. – R Sahu Oct 21 '15 at 18:46
  • I know, but then I saw [this](http://stackoverflow.com/a/3206195/2328352). I'm already looking into how to use g++ – André Fratelli Oct 21 '15 at 18:49
0

In this case I think, overloading simply does the trick. You don't really need templates here.

void archive(Archiver & archiver, const Header & obj);
void archive(Archiver & archiver, const Footer & obj);
void archive(Archiver & archiver, const Whatever & obj);
cdonat
  • 2,748
  • 16
  • 24