如何强制编译器在c++；对于模板类 < P>我想为Fibonacci类创建一个下一个元素方法，用于一个C++类IM，但是我希望它能为字符串和long工作，而不必编写两个单独的方法。

我编写了一个模板函数，但编译器无法检查if语句，因此它总是说可以对字符串类型使用

std:：to_string（）

，编译器将失败

因此，我必须使用两种方法来处理字符串和long

        template <typename T>
        void fib<T>::next_ele(){
            if(typeid(a_) == typeid(long(0))){
                std::cout<<typeid(a_).name();
                T nextp = a_ + b_;
                seq_+=",";
                seq_+=std::to_string(nextp);
                a_ = b_;
                b_ = nextp;     
            }
            else{
                T nexte = b_ + a_;
                seq_+=",";
                seq_+=nexte;
                a_ = b_;
                b_ = nexte;
            }

        }

模板
void fib:：next_ele（）{
if（typeid（a)）=typeid（long（0）））{
std:：cout是：问题在于
std:：to_string（）
函数。该函数存在于
long
中，但不存在于
std:：string
中

和
std:：to_string（）
即使
T
是
std:：string
（如果未执行该部分代码），也会编译它

如果你真的想要一个单一的方法（但是…专门化有什么问题？）。我想你可以使用
std:：ostringstream
，它可以处理整数和字符串，而不是
std:：to_string（）
；类似的东西

template <typename T>
   void fib<T>::next_ele(){

      std::cout << "typename is [" << typeid(a_).name() << "]\n";

      std::ostringstream  oss;

      T nextpe = ( typeid(a_) == typeid(long(0)) ? a_ + b_ : b_ + a_ );

      oss << ',' << nextpe;

      seq_ += oss.str();
      a_    = b_;
      b_    = nextpe;
   }

模板
void fib:：next_ele（）{
std：：cout谷歌搜索“模板专门化”。无论如何，你都会编写单独的方法。好的，那么我该如何格式化这些方法来识别是调用long方法还是string方法呢？谢谢你的帮助。我想我有一个解决方案给你，但是你知道语句
T nexte=b_+a_；
只会将字符串连接在一起，而不是实际上的“add”任何东西？结果将是一个不断增加的0和1字符串（例如，
10101101101
），而不是任何表示斐波那契序列的东西。如果这是您想要的，我将分享我的解决方案。谢谢！这是我一直在寻找的答案
        #ifndef FIBH
        #define FIBH

        #include <string>
        using std::string;
        #include <typeinfo>
        #include <iostream>
        namespace cus{
            template <typename T>
            class fib{
                private:

                public:
                    string seq_;
                    T a_;
                    T b_;
                    fib() : seq_("0,1") , a_(long(0)), b_(long(1)){};
                    fib(T a, T b) : seq_(""), a_(a), b_(b) {};
                    void next_ele(long);
                    void next_ele(string);
                    friend std::ostream& operator<<(std::ostream& out,fib& f){
                out<<f.seq_;
                return out;
            };


            };

        template <typename T>
        void fib<T>::next_ele(long b){
            long nextp = a_ + b_;
            seq_+=",";
            seq_+=std::to_string(nextp);
            a_ = b_;
            b_ = nextp; 
        }   
        template <typename T>
        void fib<T>::next_ele(string a){
                string nexte = b_ + a_;
                if (!(seq_.empty()))
                    seq_+=",";
                seq_+=nexte;
                a_ = b_;
                b_ = nexte;
            }

        }

        #endif

template <typename T>
   void fib<T>::next_ele(){

      std::cout << "typename is [" << typeid(a_).name() << "]\n";

      std::ostringstream  oss;

      T nextpe = ( typeid(a_) == typeid(long(0)) ? a_ + b_ : b_ + a_ );

      oss << ',' << nextpe;

      seq_ += oss.str();
      a_    = b_;
      b_    = nextpe;
   }