C++ 可以定义一个C++；变量以接受任何双向运算符？

无论设计是否合理，我的

main（）

方法声明了一个变量，该变量需要期望任何迭代器满足

BidirectionalIterator

定义（特别是

list:：iterator

或

vector:：iterator

），它基于所使用的数据结构（由输入参数确定）。既然我不能模板化

main（）

方法，那么如何实现这一点呢

例如，而不是：

int main(int argc, const char* argv[]) {
    vector<Person>::iterator iterator0;
    list<Person>::iterator iterator1);
    multimap<string, Person>::iterator iterator2;
}

---

然后，我不必不断地检查程序使用什么样的数据结构和if语句来存储迭代器，并使用我想要的迭代器。

听起来您想要typedefs：

typedef std::vector<Person> person_container;
typedef person_container::iterator mybidirectionaliterator;

typedef std:：vector person\u容器；
typedef person_container:：迭代器mybidirectionaliterator；

然后，每当您想要更改底层容器时，您所要做的就是将

std:：vector

更改为其他内容。尽管您仍然无法在此处分配任何迭代器，但必须使用兼容的迭代器。但是，您熟悉C++11中的

auto

关键字吗？很多时候你再也不用写迭代器了，例如，

auto-myiter=some_container.begin（）就足够了

另外，为了得到更好的答案，它有助于显示您如何使用迭代器，而不仅仅是声明迭代器。
我认为您需要的是类型擦除。您可以将其视为接口的反向。您可以想象接口位于类的底部，确定它需要提供什么方法。一个类型擦除对象排序附加在顶部，并“提取”某些方法，引入duck类型。这是一个易于使用的概念

下面是如何在普通C++ 11中工作（它也可以很容易地在11前C++中工作），但是我想要
要使用
唯一\u ptr
）：

#包括
#包括
#包括
#包括
使用名称空间std；
类人{}；
模板
类TypeReasedBidDirectionalIterator{
公众：
虚空运算符++（）=0；
虚空运算符--（）=0；
虚拟T运算符*（）=0；
};
模板
类双向迭代器适配器：公共类型ErasedBidirectionalIterator{
迭代器；
公众：
双向迭代器适配器（迭代器it）：it（it）{}
void运算符++（）{it++；}
void运算符--（）{it--；}
T&运算符*（）{*it；}
};
模板
唯一的\u ptr生成迭代器（迭代器it）{
typedef typename迭代器：：value_type T；
返回唯一的_ptr（新的双向适配器（it））；
}
typedef typeerasedbidDirectionalIterator personiter；
typedef unique_ptr PersonIteratorPtr；
int main（）{
向量向量机；
列表lst；
一、推回（Person（））；
PersonIteratorPtr it=makeIterator（vec.begin（））；
it=makeIterator（lst.begin（））；
++*它；
--*它；
**它；
}

请注意，通过将
PersonIteratorPtr
包装到另一个公开方法的类中
您可以直接摆脱类似指针的行为，但我不想让概念证明变得更加复杂
 你能更具体地说明你想做什么吗？目前，听起来您想将迭代器传递给
main（）
，这没有意义。请显示实际代码（而不仅仅是给出描述）。请显示实际代码（以及给出描述）。将代码移出
main
并移入函数模板。
typedef std::vector<Person> person_container;
typedef person_container::iterator mybidirectionaliterator;

#include<iostream>
#include<vector>
#include<list>
#include<memory>
using namespace std;

class Person{};


template <class T>
class TypeErasedBidirectionalIterator {
public:
    virtual void operator++()=0;
    virtual void operator--()=0;
    virtual T& operator*()=0;
};

template <class T, class Iterator> 
class BidirectionalIteratorAdaptor: public TypeErasedBidirectionalIterator<T> {
    Iterator it;
public:
    BidirectionalIteratorAdaptor(Iterator it): it(it){}
    void operator++(){it++;}
    void operator--(){it--;}
    T& operator*(){*it;}
};

template <class Iterator>
unique_ptr<BidirectionalIteratorAdaptor<typename Iterator::value_type,Iterator> > makeIterator(Iterator it) {
    typedef typename Iterator::value_type T;
    return unique_ptr<BidirectionalIteratorAdaptor<T,Iterator> >(new BidirectionalIteratorAdaptor<T,Iterator>(it));
}

typedef TypeErasedBidirectionalIterator<Person> PersonIterator;
typedef unique_ptr<PersonIterator> PersonIteratorPtr;


int main() {
    vector<Person> vec;
    list<Person> lst;
    lst.push_back(Person());
    PersonIteratorPtr it = makeIterator(vec.begin());
    it = makeIterator(lst.begin());
    ++*it;
    --*it;
    **it;
}