c++；模板编程：如何调用type'；s函数？ 我是C++模板编程新手。

我想做的是为其项的特定属性编写一个具有固定容量的通用容器

template <typename T >
    class SinkContainer{

    std::list<T> _buffer;

    int sum(); // i don't know how to implement this :-(
    public:
    void push_back(T a);
}

或

容器只能包含帐户或仓库的

MAX_NUM

，这意味着每次我们插入缓冲区时，我们都需要汇总当前的帐户总数或wharehouse的数量

---

有人能推荐一种编写这个通用容器的方法吗？我是否应该为

Client

和

Supplier

跳过+？

在类Client和Supplier中编写一个“Getter”方法来获取其number属性

这样，您就可以随时调用这些方法，只需求和

int sum(void){
int iSum = 0;
for(std::list<T>::iterator it = _buffer.begin();it!=_buffer.end();++it){
    iSum+=it->GetNum();
}
return iSum;    
}

int和（无效）{
int iSum=0；
对于（std:：list:：iterator it=_buffer.begin（）；it！=_buffer.end（）；++it）{
iSum+=it->GetNum（）；
}
返回iSum；
}

在类Client和Supplier中编写一个“Getter”方法来获取其number属性

这样，您就可以随时调用这些方法，只需求和

int sum(void){
int iSum = 0;
for(std::list<T>::iterator it = _buffer.begin();it!=_buffer.end();++it){
    iSum+=it->GetNum();
}
return iSum;    
}

int和（无效）{
int iSum=0；
对于（std:：list:：iterator it=_buffer.begin（）；it！=_buffer.end（）；++it）{
iSum+=it->GetNum（）；
}
返回iSum；
}

这通常使用所谓的traits类来解决。基本上，您定义了一个适配器，它为您的模板提供了一个统一的接口

// Traits class definition
template <class T>
struct SinkSumTraits;

template <>
struct SinkSumTraits<Client>
{
    static int summand(const Client &c) { return c.num_of_accounts; }
};

template <>
struct SinkSumTraits<Supplier>
{
    static int summand(const Supplier &s) { return s.num_of_warehouse; }
};


// Traits class usage

template <typename T >
class SinkContainer {
    std::list<T> _buffer;

    int sum()
    {
        return std::accumulate(
            _buffer.begin()
            , _buffer.end()
            , 0
            , [](int s, const T &a) { return s + SinkSumTraits<T>::summand(a); }
        );
    }
public:
    void push_back(T a);
}

//Traits类定义
模板
结构特征；
模板
结构特征
{
静态int summand（const Client&c）{return c.num_of_accounts；}
};
模板
结构特征
{
静态int summand（const Supplier&s）{return s.num_of_warehouse；}
};
//特征类用法
模板
类集装箱{
std:：list\u缓冲区；
整数和（）
{
返回标准：：累积(
_buffer.begin（）
，_buffer.end（）
, 0
，[]（int s，const T&a）{返回s+SinkSumTraits:：summand（a）；}
);
}
公众：
无效推回（TA）；
}

---

注意：如果没有C++11（对于

sum（）

中使用的lambda），只需将其替换为

SinkSumTraits:：summand（）

的其他用法，这通常通过所谓的traits类来解决。基本上，您定义了一个适配器，它为您的模板提供了一个统一的接口

// Traits class definition
template <class T>
struct SinkSumTraits;

template <>
struct SinkSumTraits<Client>
{
    static int summand(const Client &c) { return c.num_of_accounts; }
};

template <>
struct SinkSumTraits<Supplier>
{
    static int summand(const Supplier &s) { return s.num_of_warehouse; }
};


// Traits class usage

template <typename T >
class SinkContainer {
    std::list<T> _buffer;

    int sum()
    {
        return std::accumulate(
            _buffer.begin()
            , _buffer.end()
            , 0
            , [](int s, const T &a) { return s + SinkSumTraits<T>::summand(a); }
        );
    }
public:
    void push_back(T a);
}

//Traits类定义
模板
结构特征；
模板
结构特征
{
静态int summand（const Client&c）{return c.num_of_accounts；}
};
模板
结构特征
{
静态int summand（const Supplier&s）{return s.num_of_warehouse；}
};
//特征类用法
模板
类集装箱{
std:：list\u缓冲区；
整数和（）
{
返回标准：：累积(
_buffer.begin（）
，_buffer.end（）
, 0
，[]（int s，const T&a）{返回s+SinkSumTraits:：summand（a）；}
);
}
公众：
无效推回（TA）；
}

注意：如果您没有C++11（对于

sum（）

中使用的lambda），只需将其替换为

SinkSumTraits:：summand（）

“具有固定容量的通用容器”是对

std:：array

的描述（或

boost:：array

，具体取决于您可以使用哪种容器）。至于泛型求和，我不确定这个操作是否应该是容器的一部分。我相信使用泛型函数处理由一对迭代器指定的任意STL样式序列，由迭代器的

value\u type

调度的方法是一个更干净的解决方案。或者，更好的是，为每个使用

std:：for\u。类似于

int extract_number(const Client& c)
{
    return c.num_of_accounts;
}

int extract_number(const Supplier& s)
{
    return s.num_of_wareouse;
}

template <typename Iter>
int sumStuff(Iter begin, Iter end)
{
    typedef typename Iter::value_type type;
    int sum;
    std::for_each(begin, end, [&sum](const type& item)
    {
        sum += extract_number(item);
    }
    return sum;
}

int-extract\u编号（const-Client&c）
{
返回帐户的c.num；
}
int extract_编号（const Supplier&s）
{
返回wareouse的s.num；
}
模板
国际热核实验堆（Iter开始，Iter结束）
{
typedef typename Iter:：value_type类型；
整数和；
标准：：每个（开始、结束、[&和]（常数类型和项目）
{
总和+=提取号（项目）；
}
回报金额；
}

这样，操作和容器就解耦了，我们得到了一个整洁的、参数多态的求和函数。
“具有固定容量的通用容器”是对
std:：array
（或
boost:：array
，取决于您可以使用哪种类型，如果有的话）.至于泛型求和，我不确定这个操作是否应该是容器的一部分。我相信，使用泛型函数处理由迭代器对指定的任意STL样式序列，由迭代器的
value\u type
调度的方法是一个更干净的解决方案。或者，更好的是，使用
std:：for\u each
。还有其他方法台词

int extract_number(const Client& c)
{
    return c.num_of_accounts;
}

int extract_number(const Supplier& s)
{
    return s.num_of_wareouse;
}

template <typename Iter>
int sumStuff(Iter begin, Iter end)
{
    typedef typename Iter::value_type type;
    int sum;
    std::for_each(begin, end, [&sum](const type& item)
    {
        sum += extract_number(item);
    }
    return sum;
}

int-extract\u编号（const-Client&c）
{
返回帐户的c.num；
}
int extract_编号（const Supplier&s）
{
返回wareouse的s.num；
}
模板
国际热核实验堆（Iter开始，Iter结束）
{
typedef typename Iter:：value_type类型；
整数和；
标准：：每个（开始、结束、[&和]（常数类型和项目）
{
总和+=提取号（项目）；
}
回报金额；
}

通过这种方式，操作和容器是解耦的，我们得到了一个整洁、参数多态的求和函数。
如果您不能修改客户和供应商-您可以使用模板专门化实现您想要的：

template <typename T >
class SinkContainer{

     int getCount(T t);

}

模板
类集装箱{
int getCount（T）；
}

内。cpp：

template<>
int SinkContainer<Client>::getCount(T t)
{
     return t.num_of_accounts;
}


template<>
int SinkContainer<Supplier>::getCount(T t)
{
     return t.num_of_warehouse;
}

模板
int SinkContainer:：getCount（T）
{
返回帐户的t.num；
}
模板
int SinkContainer:：getCount（T）
{
返回仓库的t.num；
}
如果您无法修改客户和供应商-您可以使用模板专门化实现您想要的：

template <typename T >
class SinkContainer{

     int getCount(T t);

}

模板
类集装箱{
int getCount（T）；
}

内。cpp：

template<>
int SinkContainer<Client>::getCount(T t)
{
     return t.num_of_accounts;
}


template<>
int SinkContainer<Supplier>::getCount(T t)
{
     return t.num_of_warehouse;
}

模板
int SinkContainer:：getCount（T）
{
返回帐户的t.num；
}
模板
int SinkContainer:：getCount（T）
{
返回仓库的t.num；
}
您可以使用指向成员的指针，如下所示：

template <typename T, int T::*N>
class SinkContainer {
    bool do_push_back(T const &);
public:
    int sum();
    bool push_back(T const &t) {
        if (sum() + t.*N < MAX_NUM)
            return do_push_back(t);
        else
            return false;
    }
};

模板
类集装箱{
推_