C++ 迭代器和STL容器

我需要做一些特定的构造函数，它得到两个迭代器：开始迭代器和结束迭代器

我有一些代码及其作品：

#include <iostream>
#include <vector>

using namespace std;

template<typename T>
class A
{
public:
    T a[10];
    typename std::vector<T>::iterator itStart, itEnd;
    A(typename vector<T>::iterator itStart, typename vector<T>::iterator itEnd):itStart(itStart),itEnd(itEnd){}

    void see()
    {
        int i=0;
        while(itStart != itEnd)
        {
            cout<<*itStart<<endl;
            a[i] = *itStart;
            itStart++;
            i++;
        }
    }
};

template <typename Iterator>
double Sum( Iterator begin, Iterator end );

int main()
{
    cout << "Hello world!" << endl;
    vector<int> v;
    v.push_back(1);
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);


    class A<int> a(v.begin(),v.end());
    a.see();
    return 0;
}

#包括
#包括
使用名称空间std；
模板
甲级
{
公众：
Tα[10]；
typename std:：vector:：迭代器itStart，itEnd；
A（类型名向量：：迭代器itStart，类型名向量：：迭代器itEnd）：itStart（itStart），itEnd（itEnd）{
void见（）
{
int i=0；
while（itStart！=itEnd）
{
显然，您需要使迭代器类型成为类的模板参数

template<class T, class Iter>
class A
{
   Iter first, last;
   A(Iter first, iter last):first(first), last(last){}
};

模板
甲级
{
国际热核实验堆第一，最后；
（国际热核实验堆第一，国际热核实验堆最后）：第一（第一），最后（最后）{}
};

但是现在显式指定模板参数变得不舒服了

A<int, vector<int>::iterator > a;

A；

为了避免这种情况，只需创建一个工厂函数

   template<class T, class Iter>
   A<T, Iter> make_A(Iter first, iter last)
   {
       return A<T, Iter>(first, last);  
   }

模板
制造（国际热核实验堆第一，国际热核实验堆最后）
{
返回A（第一个，最后一个）；
}

现在，您可以使用函数，而不是直接创建的对象

   auto my_A =  make_A<int>(v.begin(), v.end());

auto my_A=make_A（v.begin（），v.end（））；
查看STL的其中一项功能，例如：

template
填空（先转寄，后转寄，常数T和值）；

我们可以受到启发：

template<typename ITR, typename T>
class A
{
  A(ITR itStart, ITR itEnd):itStart(itStart),itEnd(itEnd){}
  ...

模板
甲级
{
A（ITR itStart，ITR itEnd）：itStart（itStart），itEnd（itEnd）{
...
也许您可以利用输入序列（iseq）的概念

输入序列由一对迭代器（开始和结束）表示

当然，您需要创建所有接受iseq而不是一对迭代器的STL算法的重载

然后，您的示例可以使用for_each（重载以接受iseq）

示例代码可以在TC++PL第三版（Stroustrup）第18.3.1节中找到。
我问的是另一种方法。不要解决我的懒惰。你希望
A
的成员
itStart
和
itEnd
是非特定的-正确吗？类似的事情，它们将被检测（类型集、映射等）.当constructor调用时如果你确实重载了构造函数，你会怎么做？你会使用什么类型的构造函数来启动和终止？你可能会发现这很有用：你的答案很好。这就是我需要的。THX
template< class ForwardIt, class T >
void fill( ForwardIt first, ForwardIt last, const T& value );

template<typename ITR, typename T>
class A
{
  A(ITR itStart, ITR itEnd):itStart(itStart),itEnd(itEnd){}
  ...