Stream Insertion Operator << Overloading Undefined Symbols for architecture x86_64 Error

Question

I'm currently learning how to overload the stream insertion operator for my class. Found below is the code I have:

#include <iostream>
#include <string>

using std::string;
using std::endl;
using std::cout;

template<typename T>
class A {
    public:
        A(T);
    friend std::ostream& operator<<(std::ostream&, const A&);
    T* value;
};

template<typename T>
A<T>::A(T input) {*value = input;}

template<typename T>
std::ostream& operator<<(std::ostream& out, const A<T>& obj) {
    out << *(obj.value);
    return out;
}

int main() {
    A<string> foo("HELLO");
    cout << foo << endl; 
    return 0;
}

I'm getting this error after compiling the code with G++

Undefined symbols for architecture x86_64:
  "operator<<(std::__1::basic_ostream<char, std::__1::char_traits<char> >&, A<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > const&)", referenced from:
      _main in streamops-ef073c.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

Any idea what could be wrong? I'm following a guide and don't see the difference in my operator overload.

score 1 · Answer 1 · answered Sep 16 '20 at 03:24

1

The problem is that the friend declaration declares the function as a non-template function.

You need to declare it as a template:

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

Optionally you could define the function inline inside the class:

friend std::ostream& operator<<(std::ostream& out, const A& obj) {
    return out << *(obj.value);
}

answered Sep 16 '20 at 03:24

Some programmer dude

400,186
35
402
621

So I have to to include another `template` inside the class declaration? Or can I use the class template I've used? – Chronollo Sep 16 '20 at 03:35
@MAGEPAC You must use a separate template name, as shown in my answer. – Some programmer dude Sep 16 '20 at 03:43

R Sahu · Answer 2 · 2020-09-16T03:53:31.727

One option is to use a combination of a class member function and a non-member function.

template <typename T>
class A
{
    public:

        A(T);

        std::ostream& write(std::ostream& out) const
        {
           return out << *value;
        }

        T* value;
};


template <typename T>
std::ostream& operator<<(std::ostream& out, const A<T>& obj)
{
   erturn obj.write(out);
}

Word of caution for the way you have defined you class.

When the constructor gets invoked, your code will run into undefined behavior. You are using

*value = input;

without value having been initialized to point to a valid object. That is not good.

Stream Insertion Operator << Overloading Undefined Symbols for architecture x86_64 Error

2 Answers2