Understanding templates in c++

Question

I am trying run the following program, But it generates compilation error:

#ifndef TEMPLATE_SUM_H_
#define TEMPLATE_SUM_H_

template<typename T>
class sum
{
  public:
    sum() {
      val_1 = 0;
      val_2 = 0;
    }
    sum(T a, T b) {
      val_1 = a;
      val_2 = b;
    }
    friend std::ostream& operator<<(std::ostream &, const sum<> &);

  private:
    T val_1, val_2;
    T result() const;
};

#endif

Source file:

include <iostream>
#include "inc/sum.h"

template<typename T>
T sum<T>::result() const {
   return (val_1 + val_2);
}

template<typename T>
std::ostream& operator<<(std::ostream& os, const sum<T>& obj) {
//std::ostream& operator<<(std::ostream& os, sum<T>& obj) {
  os << obj.result();
  return os;
}

int main()
{
    sum<int> int_obj(15, 15);
    sum<float> float_obj(5.2, 3.5);
    std::cout << "result of int = " << int_obj << std::endl;
    std::cout << "result of float = " << float_obj << std::endl;
    return 0;
}

Compiling with g++ (4.4.3) it generates following error:

In file included from template.cpp:2:
inc/sum.h:18: error: wrong number of template arguments (0, should be 1)
inc/sum.h:5: error: provided for ‘template<class T> class sum’
template.cpp: In function ‘std::ostream& operator<<(std::ostream&, const sum<T>&) [with T = int]’:
template.cpp:20:   instantiated from here
template.cpp:5: error: ‘T sum<T>::result() const [with T = int]’ is private
template.cpp:12: error: within this context
template.cpp: In function ‘std::ostream& operator<<(std::ostream&, const sum<T>&) [with T = float]’:
template.cpp:21:   instantiated from here
template.cpp:5: error: ‘T sum<T>::result() const [with T = float]’ is private
template.cpp:12: error: within this context

1) Can Anyone please help me in identifying the error ? Also Please suggest some links where I can find brief absolute details on how to use templates in c++.

2) I read that templatized func/classes declared in header file, and defined separately are prone to linking error. Can anyone explain/elaborate this ? Is there any possibility of linking error in above example ?

The statement is as below:

"If a template or inline function is declared in a .h file, define it in that same file. The definitions of these constructs must be included into every .cpp file that uses them, or the program may fail to link in some build configurations."

This example can be done in some more easy way, without using overloaded operator etc. But I am trying to learn/practising templates and experimenting some features.

Answer 1

A simple sample source, to get started;

Calculator.h

#ifndef CALCULATOR_H
#define CALCULATOR_H

template <class TYPE>
class Calculator{

public:
    Calculator();
    TYPE Sum(TYPE param1, TYPE param2);

};


/**
 * To avoid template related compilation error
 * when templates are used in header and source files
 *
 * This class file has been removed from the project-source file.
 * However, is present in the project folder
 * Gets compiled with the header-file (being included)
 */
#include "Calculator.cpp"

#endif

Calculator.cpp

#include <iostream>
using namespace std;
#include "Calculator.h"


template <class TYPE>
Calculator<TYPE>::Calculator()
{
}

template <class TYPE>
TYPE Calculator<TYPE>::Sum(TYPE param1, TYPE param2){

    cout << "Calculator::sum" << endl;
    cout << param1 <<endl;
    cout << param2 <<endl;

    TYPE result = param1 + param2 ;

    return result;
}

Main.cpp

#include <iostream>
using namespace std;
#include "Calculator.h"

int main(int argc, const char * argv[]) {
    cout << "Hello, Calculator!\n";

    Calculator<int> cObj;
    int out = cObj.Sum(2,3);
    cout << "out : " << out << endl;

    Calculator<string> cObjS;
    string outS = cObjS.Sum("A", "B");
    cout << "outS : " << outS << endl;

    cout << "Bye, Calculator!\n";


    return 0;
}

Additionally, you can refer to the post, to know about how to keep the template source and header contents, and knowing about how to fix the compilation and linker issues (with reasons).

Answer 2

You need to have a separate template definition for the friend function declaration:

template<typename U>
friend std::ostream& operator<<(std::ostream &, const sum<U> &);

friend declarations do not inherit the template parameters of the enclosing class.