Templated classes...

I am attempting to learn templated classes and functions, and figured with a templated class I could learn both easily.

main.cpp -

Code:

---

#include <iostream>
#include <string>
#include "newtemplate.h"

int main() {
    newtemplate<int> test(5);
    newtemplate<std::string> test2;
    test2.print("\nblah");
    return 0;
}

---

newtemplate.h -

Code:

---

#ifndef NEWTEMPLATE_H
#define NEWTEMPLATE_H
template <class type>
class newtemplate {
    public:
        newtemplate() {};
        newtemplate(type a);
        ~newtemplate() {};
        void print(type a);
};

#endif //NEWTEMPLATE_H

---

newtemplate.cpp -

Code:

---

#include <iostream>
#include "newtemplate.h"

template <class type> newtemplate<type>::newtemplate(type a) {
    std::cout<<a;
}

template <class type> void newtemplate<type>::print(type a) {
    std::cout<<a;
}

---

Quote:

---

C:\DATA\development\cpp\newtemplate\newtemplate\ma in.cpp:6: undefined reference to `newtemplate<int>::newtemplate(int)'
C:\DATA\development\cpp\newtemplate\newtemplate\ma in.cpp:8: undefined reference to `newtemplate<std::string>::print(std::string)'
:: === Build finished: 2 errors, 0 warnings ===

---

I assume this is how it should be written from the FAQ on this site and a couple others... could someone point out my errors?

Implementations of templates must be in header files. For the reason, search the board.

I just saw why in the parashift C++ FAQ Lite, kinda annoying though, I am used to my definitions being in another file than the declarations... oh well.

Code:

---

template <class type>

---

I think that usage of the class keyword is deprecated in favor of typename.

>I am used to my definitions being in another file than the declarations... oh well.
Technically a template is nothing more than a declaration. It's a template (hence the name) for a class or function where the parameters are replaced with explicit types or values provided by the user code.

>I think that usage of the class keyword is deprecated in favor of typename.
Some people may prefer typename over class (I'm one of them), but class is not deprecated for that use. It's a matter of style. Some people use typename when non-class types can be expected and class when only class types are expected. That's the only readability excuse I've seen that holds water, but I don't subscribe to it because it's misleading in that it looks like a constraint but really isn't.

>> I am used to my definitions being in another file than the declarations... oh well.
One common technique is to leave the "definitions" in the source file and #include that at the bottom of the header file. Some would prefer that you use a different prefix (like .inl) for the source file in that case so as to avoid including a cpp file.

Ahh, nice idea Daved, thanks!

Some compilers (g++ is among them) support extensions so they don't specifically require implementation of templates to be in header files. The catch, however, is that the techniques are compiler dependent, are typically disabled by default (i.e. if you want to do it, you need to enable specific compiler options), and typically rely on the project including a separate source file that (typically) #include's both the header and source file for the template and manually specialises templates for the types you use.