我之前在这里问过这个问题，但没有得到答案，只是"绕路"。现在，我正试图找到这个问题的实际解决方案（如下所述）。在有人说这个问题以前被问过之前，我想说的是，我尝试了这里、这里、这里和这里提供的解决方案——没有任何帮助：（

问题是链接器说Undefined symbols for architecture x86_64时没有任何其他警告或错误。调用、完整错误消息和正在编译的代码如下所示。

注意：如果我在内联中定义operator<<，问题就会消失，但这并不是一个真正的解决方案，而是一个迂回：）

提前感谢：）

调用与环境

环境：

• 操作系统：Mac OS X Yosemite（10.10.4）
• X代码：6.4（6E35b）
• uname -a:Darwin wireless1x-XXX-XXX-XXX-XXX.bu.edu 14.4.0 Darwin Kernel Version 14.4.0: Thu May 28 11:35:04 PDT 2015; root:xnu-2782.30.5~1/RELEASE_X86_64 x86_6
• g++ --version:Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1 Apple LLVM version 6.1.0 (clang-602.0.53) (based on LLVM 3.6.0svn) Target: x86_64-apple-darwin14.4.0 Thread model: posix

运行参数：

g++ -std=c++11 -lm -stdlib=libc++ tstLinkedList1.cpp -o tstLinkedList1

或

g++ -std=c++11 -lm -stdlib=libstdc++ tstLinkedList1.cpp -o tstLinkedList1

我还尝试在这两种情况下添加-lc++——同样的事情：（

错误

编辑：operator<<重载中发生错误，该重载定义在下面的LinkedList.hpp文件的最后

使用-stdlib=libc++:

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

使用-stdlib=libstdc++:

Undefined symbols for architecture x86_64:
  "operator<<(std::ostream&, LinkedList<int> const&)", referenced from:
      _main in tstLinkedList1-8d9300.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

代码

LinkedList.hpp:

#pragma once
template <typename T> class LinkedList;
template <typename T>
std::ostream& operator<<(std::ostream& os, const LinkedList<T>& list);

/** Node class
 * 
 * @tparam T template type
 */
template <typename T>
class Node {
private:
  T _elem;                      //!< Stored value
  Node<T>* _next;               //!< Next element
  friend class LinkedList<T>;   //!< Friend class
};

/** Singly Linked List
 *
 * @tparam T template type
 */
template <typename T>
class LinkedList {
public:
  LinkedList();
  ~LinkedList();
  std::size_t size() const;
  bool empty() const;
  const T& front() const;
  void addFront(const T& e);
  void removeFront();
public:
  // Housekeeping
  friend std::ostream& operator<<(std::ostream& os, const LinkedList<T>& list);
private:
  Node<T>* _head;
  std::size_t _size;
};
/** Constructor */
template <typename T>
LinkedList<T>::LinkedList() : _head(nullptr), _size(0) {}
/** Destructor */
template <typename T>
LinkedList<T>::~LinkedList() {
  while (!empty()) removeFront();
}
/** Number of elements in the list
 * 
 * @returns std::size_t Number of elements in the list
 */
template <typename T>
std::size_t LinkedList<T>::size() const {
  return this->_size;
}
/** Empty?
 *
 * @returns bool True if empty
 */
template <typename T>
bool LinkedList<T>::empty() const {
  return _head == nullptr;
}
/** Get front element (read-only)
 *
 * @returns T
 */
template <typename T>
const T& LinkedList<T>::front() const {
  return _head->_elem;
}
/** Add element in the front of the list
 * 
 * @param e Element to be added
 */
template <typename T>
void LinkedList<T>::addFront(const T& e) {
  Node<T>* v = new Node<T>;
  v->_elem = e;
  v->_next = _head;
  _head = v;
  _size++;
}
/** Remove the first element */
template <typename T>
void LinkedList<T>::removeFront() {
  if (empty()) return;
  Node<T>* old = _head;
  _head = old->_next;
  _size--;
  delete old;
}
/** Operator<< for the linked list
 *
 * @returns std::ostream
 * @param LHS->std::ostream
 * @param RHS->LinkedList<T>
 */
template <typename T>
std::ostream& operator<<(std::ostream& os, const LinkedList<T>& list) {
  os << "TEST";
  return os;
}

tst链接列表1.cpp:

#include <iostream>
#include "LinkedList.hpp"
using namespace std;
int main() {
  LinkedList<int> ll1;
  ll1.removeFront();
  ll1.addFront(1);
  std::cout << ll1 << std::endl;
}

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

// within LinkedList:
friend std::ostream& operator<<<>(std::ostream&, const LinkedList&);
// NOTE:                       ^^ here you need to add <>

// within LinkedList:
friend std::ostream& operator<<(std::ostream&, const LinkedList<T>&);

// within the global namespace
// NOTE: not a template!
std::ostream& operator<<(std::ostream&, const LinkedList<int>&);

// within LinkedList:
friend std::ostream& operator<<(std::ostream& os, const LinkedList<T>& list)
{
    // implement me!
    return os;
}