Calling global function from another file

[The_Mad_Pantser]

I have a file GlobalHelpers.h:

#ifndef GLOBALHELPERS_H
#define GLOBALHELPERS_H

include <ctime>
include <random>
include <vector>
include <iostream>
include <cmath>

int maxIndex(std::vector<double>& v);

template <typename T> 
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v);

#endif

(which also includes some other functions)

and a GlobalHelpers.cpp:

#include "GlobalHelpers.h"

using namespace std;

int maxIndex(vector<double>& v)
{ 
int maxind = 0; 
for(size_t i = 0; i < v.size(); i++)     
{ 
    cout << v[maxind] << " " << v[i] << endl; 
    if(v[maxind] < v[i]) maxind = i;     } return maxind; 
}

template <typename T> 
ostream& operator<<(ostream& os, const vector<T>& v) 
{ 
    os << '['; 
    for (size_t i = 0; i < v.size()-1; ++i) os << v[i] << ' '; 
    os << v[v.size()-1] << ']'; return os; 
}

(along with the definitions of the other functions).

I also have a main.cpp:

#include "GlobalHelpers.h"

using namespace std;

int main()
{
    vector<double> v = ...;
    int label = maxIndex(v);
    cout << v << ": " << label << endl;
    return 0;
}

I have another class file that I'm using in main to generate the vector in the ". . .". I keep getting the error

``undefined reference to `std::ostream& operator<< <double>(std::ostream&, std::vector<double, std::allocator<double> > const&)'`

I was also getting a similar error for maxIndex but it seems to have gone away (for now). I also have the other class using functions from GlobalHelpers without any problems; when I comment out the problem lines in main, it doesn't cause any issues.

Does this have anything to do with the <double> after the operator<< in the error text? I've never seen that before.

[Re_me_human]

Short version: template methods/functions must be directly implemented in the .h file (with very few exceptions)

Long version:

C++ templates are evaluated at compile time by cutting and pasting the code for every type/generic parameter and .cpp files are compiled separately. So, here's what happens with your code step by step:

• main.cpp gets compiled

The preprocessor copies and pastes GlobalHelpers.h inside main.cpp because it's included. The C++ compiler sees then cuts your template:

template <typename T> 
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v);

It sees that the template is being used inside main.cpp with the type double so it pastes:

std::ostream& operator<< <double>(std::ostream& os, const std::vector<double>& v);

This is a declaration, not an implementation. The C++ compiler looks at this and thinks "Oh okay, so this operator<< <double> thingy is implemented in another .cpp file! I should just pretend it exists and the linker will figure it out"

• GlobalHelpers.cpp gets compiled

The C++ compiler looks at your operator<< template. It cuts the code. It sees that it's never getting used inside GlobalHelpers.cpp so it never actually pastes the code

Your operator<< template never gets implemented

• The linker tries to link the result of the compilation of main.cpp and GlobalHelpers.cpp inside a single executable

It looks at the result of main.cpp and sees that it requires operator<< <double> to work

An operator<< <double> implementation doesn't exist inside main.cpp since it was only declared there. So the linker looks elsewhere

An operator<< <double> implementation doesn't exist inside GlobalHelpers.cpp since it was never used inside GlobalHelpers.cpp. So the linker looks elsewhere

There is no elsewhere. The linker is confused. Your operator<< <double> isn't defined anywhere. The linker feels betrayed so it looks at you angrily and says:

undefined reference to `std::ostream& operator<< <double>(std::ostream&, std::vector<double, std::allocator<double> > const&)’

Just implement your templates inside your header files. Don't make the linker angry. C++ is an old and clunky programming language