C++ class declarations and namespaces

Question

I'm having an issue with a C++ library I'm trying to write. It's the usual setup, one cpp file, one header file. I want the header file to only expose the parts that are meant to be used (I have an abstract base class for instance, I don't want in the header file). So far, I'm just working with a single file (I assume this should make no difference, as includes are done by the preprocessor, which doesn't care about anything).

You'll note that the "header file" is spread over two spots, before and after the header implementation file.

#include <stdio.h>

// lib.h
namespace foo {
    template <class T> class A;
}

// lib.cpp
namespace foo {
    template <class T> class A {
        private:
        T i;
        public:
        A(T i) {
            this->i = i;
        }

        T returnT() {
            return i;
        }
    };
};

// lib.h
namespace foo {
    template <class T> T A<T>::returnT();
}

// foo.cpp
void main() {
    foo::A<int> a = foo::A<int>(42);
    printf("a = %d",a.returnT());
}

So, naturally, I'd like my header file to contain just

namespace foo {
    template <class T> class A;
    template <class T> T A<T>::returnT();
}

But my compiler does not like this (it complains that returnT is not a member of foo::A<T>. The reason I don't want to put the class declaration itself in the header is that then it would (as I understand it), contain all the private and similar stuff, which I'd like to hide.

Maybe it's just me, but the following header file seems "bad", at least as an "interface specification." It exposes some of the internals of A, which a user of the lib would not need to know about.

// lib.h
namespace foo {
    template <class T> class A {
        private:
        int i;
        public:
        A(T);
        T returnT();
    };
}

// lib.cpp
namespace foo {
    template <class T> A<T>::A(T i) {
        this->i = i;
    }
    template <class T> T A<T>::returnT() {
        return i;
    }
};

Is this the accepted way of doing it? I'd like a more abstract header file, if at all possible.

Is the entire first block of code the header file code? I'm confused because there are two blocks labelled "lib.h" but then you have a main function there... — James McNellis
– James McNellis, Commented Jan 24, 2011 at 18:36
Get used to disclose your implementation details when you write the word template. This is how it works, period. You can make "implementation header files" that you #include into your main header, but you have to ship the source. — Alexandre C.
– Alexandre C., Commented Jan 24, 2011 at 18:37
@James McNellis: The first code piece (the grey block) is just a test file I used to keep everything in one file. The idea is that this would be split out into three files, lib.h, lib.cpp and main.cpp, the last just being the "user" test, calling into lib. The problem just is that to get something that looks like what I want, I need to split the header, into one part above the implementation code, and to one part below it. Does that make sense? — Svend
– Svend, Commented Jan 24, 2011 at 19:44

James McNellis · Accepted Answer · 2011-01-24 18:39:33Z

6

You cannot separate the definition of a template from its declaration. They both have to go into the header file together.

For "why?" I recommend reading "Why can't I separate the definition of my templates class from its declaration and put it inside a .cpp file?".

I may have misread your question. To address what may also be your question, this is not valid:

namespace foo {
    template <class T> class A;     
    template <class T> T A<T>::returnT(); 
}

It is not valid for the same reason that this is not valid:

namespace foo {
    class A;
    int A::returnT();
}

Member functions must be declared inside the definition of the class.

edited Jan 24, 2011 at 18:39

answered Jan 24, 2011 at 18:34

James McNellis

357k76 gold badges934 silver badges983 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

mmmmmmmm · Accepted Answer · 2011-01-24 19:09:11Z

2

There are two problems with .cpp files you are dealing here:

I. If you want to put an instance of that class on the stack (like you do in your main()) the compiler needs to know the size of the class (to allocate enough memory). For that it needs to know the members and by that the complete declaration.

The only way to hide the class' layout away is to built up an interface and a factory method/function and put the instance on the heap in the factory.

As an example (without the template; see below to know why):

namespace foo {
  class IA {
    public:
      virtual ~IA();
      virtual int returnT() = 0;

      static IA *Create();
  };
}

In your .cpp you then do:

namespace foo {
  class A : public IA {
    private:
      int i;
    public:
      A() : 
        i(0) {
      }
      virtual ~A() {
      }
      virtual int returnT() {
        return i;
      }
  };
  IA::~IA() {
  }

  IA *IA::Create() {
    return new A();
  }
}

BTW: Using smart pointers would be suggested...

II. Since you are using a template the method definitions must be either visible via header file or explicitly instantiated for a specific set of types.

So you can split up your code into a lib.h and a lib_impl.h:

lib.h:

namespace foo {
  template <typename T> class IA {
    public:
      virtual ~IA() {
      }
      virtual T returnT() = 0;

      static IA *Create();
  };
}

lib_impl.h:

namespace foo {
  template <typename T> class A : public IA<T> {
    private:
      T i;
    public:
      A() : 
        i(T()) {
      }
      virtual ~A() {
      }
      virtual T returnT() {
        return i;
      }
  };

  template <typename T> IA<T> *IA<T>::Create() {
    return new A<T>();
  }
}

so you include the lib_impl.h where ever you need the impleemntations. To use the explicit instantiations add a lib.cpp and just let that file allow to include lib_impl.h:

lib.cpp:

#include <lib_impl.h>
namespace foo {
  template class IA<int>;
  template class A<int>;
  template class IA<float>;
  template class A<float>;
  template class IA<char>;
  template class A<char>;
  // ...
}

answered Jan 24, 2011 at 19:09

mmmmmmmm

15.5k2 gold badges32 silver badges55 bronze badges

6 Comments

Mikael Persson Over a year ago

To add to this great answer, you can also #include lib_impl.h at the end of lib.h. This way, from the user's point-of-view, a quick look into lib.h will reveal the essentials (the interface) without requiring a look at the details in lib_impl.h nor having to do any special work to figure out when lib_impl.h should be included or not.

Svend Over a year ago

This approach (also outlined in the FAQ) is what I've ended up going with. Smart pointers is not quite where I am however ;)

Svend Over a year ago

I've a question. As I understand it, lib.cpp is used as a sort of "hinting" to the compiler, as to what templates to generate. The FAQ also mentions this approach (item 35.13), but what is this syntax doing specifically? Such as where can I look in Stroustrups book and learn something?

mmmmmmmm Over a year ago

@Svend: The explicit instantiation generates all methods for the specific instantiated template in the compile unit of lib.cpp. So a consumer of the template class can use i.e. A<char> without including the lib_impl.h since the linker can resolve the methods from the lib.dll/lib.so. The advantage is: Hidden implementation and faster over-all compilation if used often. The drawback: You cannot use A<MyClass>...

mmmmmmmm Over a year ago

@Svend: To clarify the "faster compilation times" a bit: If implementation is in lib.h or if lib_impl.h is included everywhere then the compiler instantiates the used methods in each compile unit it is used in (maybe a hundred times the same method). It's up to the linker to remove all redundant instantiations later...this takes time....

|

Collectives™ on Stack Overflow

C++ class declarations and namespaces

2 Answers 2

Comments

6 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

6 Comments

Your Answer

Sign up or log in

Post as a guest

Related