Question

编辑：我认为this question没有回答此问题，尽管可能相关。特别是，如果我通过在template class List<int*>文件的末尾添加test.cpp来使用显式实例化而不是隐式实例化（我在下面实现了这个），问题仍然存在。或者更准确地说：我不明白如何解决这个问题。谢谢！

解决：见下文。

我很难描述这个问题，所以为糟糕的头衔道歉。

我有一个包含STL向量的模板类，我正在尝试实现一些STL向量方法，使其感觉像一个向量。大多数函数都很好，但我遇到了一个带有insert函数的孤立问题，该函数带有另一个向量的迭代器（即＆＃34;范围＆＃34;变体，见here）：

template <class InputIterator>
iterator insert (const_iterator position, InputIterator first, InputIterator last);

一个额外的复杂因素是类的模板参数是指针，例如List<int*>是vector<int*>，而不仅仅是vector<int>。

以下是该类的简化标题：

test.hpp

#include <iostream>
#include <vector>

// Briefly declare List
template <typename T>
class List;

template <typename T>
class List<T*> {    
public:

    // Vector as list
    typename std::vector<T*> _list;

    // Constructor
    List();

    // Typedefs to hide that the iterators actually refer to the STL container
    typedef typename std::vector<T*>::iterator iterator;
    typedef typename std::vector<T*>::const_iterator const_iterator;
    typedef typename std::vector<T*>::value_type value_type;

    // Iterators
    iterator begin();
    const_iterator begin() const;
    iterator end();
    const_iterator end() const;

    // Insert functions
    // Single element
    iterator insert (const_iterator position, const value_type& val);
    // Range
    template <typename InputIterator>
    iterator insert (const_iterator position, InputIterator first, InputIterator last);
};

这是它的实施

TEST.CPP

#include "test.hpp"

// Constructor
template <typename T>
List<T*>::List() {};

// Iterators
template <typename T>
typename List<T*>::iterator List<T*>::begin() {return this->_list.begin();};
template <typename T>
typename List<T*>::const_iterator List<T*>::begin() const {return this->_list.begin();};
template <typename T>
typename List<T*>::iterator List<T*>::end() {return this->_list.end();};
template <typename T>
typename List<T*>::const_iterator List<T*>::end() const {return this->_list.end();};

// Single element insert function
template <typename T>
typename List<T*>::iterator List<T*>::insert (typename List<T*>::const_iterator position, const typename List<T*>::value_type& val)
{
    return this->_list.insert(position,val);
};

// Range insert function
template <typename T>
template <typename InputIterator>
typename List<T*>::iterator List<T*>::insert (typename List<T*>::const_iterator position, InputIterator first, InputIterator last) {
    return this->_list.insert(position,first,last);
};

// Explicitly instantiate a List<int*> class
template class List<int*>;

现在我编写一个简单的程序来测试它：

run.cpp

#include "test.hpp"

int main() {

    // Make two lists
    List<int*> list_1;
    List<int*> list_2;

    // Add some elements
    int i1 = 1;
    int i2 = 2;
    int i3 = 3;
    int i4 = 4;
    int i5 = 5;

    // list_1 = [2,1]
    list_1.insert(list_1.begin(), &i1);
    list_1.insert(list_1.begin(), &i2);

    // list_2 = [5,4,3]
    list_2.insert(list_2.begin(), &i3);
    list_2.insert(list_2.begin(), &i4);
    list_2.insert(list_2.begin(), &i5);

    // list_1 = [5,4,3,2,1]
    list_1.insert(list_1.begin(),list_2.begin(),list_2.end());

    for(auto const& value: list_1) {
        std::cout << "list_1: " << value << " " << *value << std::endl;
    };

    return 0;
}

使用g++ run.cpp -std=c++14进行编译会产生symbol(s) not found for architecture x86_64错误。

但是，如果我将整个int main()复制并粘贴到test.cpp文件的末尾，然后使用g++ run.cpp -std=c++14进行编译，那么一切都可以正常工作预期

1）补救措施是什么？

2）为什么仅针对插入函数的变体（范围变体）会出现此问题？例如，仅使用单个元素变体可以正常工作。我猜这可能与使用两个模板有关吗？

感谢您的帮助！

编辑解决方案基于标记为重复的问题和以下评论。

我补充说：

template List<int*>::iterator List<int*>::insert (List<int*>::const_iterator position, 
List<int*>::iterator first, List<int*>::iterator last);

在test.cpp的底部，也可以创建这个类方法的显式实例化。

获得的经验：如果模板类有模板方法，模板方法也需要显式实例化。

嵌套容器STL向量的模板类：insert方法

0 个答案: