为什么尝试存储指向函数模糊的指针

Question

这是我的代码:

    #include <functional>
    #include <iostream>
    #include<vector>

    using namespace std;

    // vector iterator
    template <class T> class vit
    {
            private:
            //vector<T>::iterator it;
            vector<T> m_v;
            function<bool (T, T)> m_fptr;
            int len, pos;
            public:
            vit(vector<T> &v) { this->m_v = v; len = v.size(); pos = 0;};
           //       it= v.begin(); };
            bool next(T &i) {
                    //if(it == m_v.end()) return false;
                    if(pos==len) return false;
                    //i = *it;
                    i = m_v[pos];
                    //if(idle) { idle = false ; return true; }
                    //it++;
                    pos++;
                    return true;};
            //bool idle = true;
            void set_same(function<bool (T,T)> fptr) { m_fptr = fptr ;};
            //void set_same(function<bool(int, int)> fun) { return ; }
            bool grp_begin() {
                    return pos == 0 || ! m_fptr(m_v[pos], m_v[pos-1]); };
            bool grp_end() {
                    return pos == len || ! m_fptr(m_v[pos], m_v[pos+1]); };
    };


    bool is_same(int a, int b) { return a == b; }

    main()
    {
            vector<int>  v ={ 1, 1, 2, 2, 2, 3, 1, 1, 1 };
            int total;
            for(auto it = v.begin(); it != v.end(); it++) {
                    if(it == v.begin() || *it != *(it-1)) {
                            total = 0;
                    }

                    total += *it;

                    if(it+1 == v.end() || *it != *(it+1)) {
                            cout << total << endl;
                    }
            }

            cout << "let's gry a group" <<endl;
            vit<int> g(v);
            int i;
            while(g.next(i)) { cout << i << endl; }

            cout << "now let's get really fancy" << endl;
            vit<int> a_vit(v);
            //auto is_same = [](int a, int b) { return a == b; };
            a_vit.set_same(is_same);
            //int total;
            while(a_vit.next(i)) {
                    if(a_vit.grp_begin()) total = 0;
                    total += i;
                    if(a_vit.grp_end()) cout << total << endl ;
            }
    }        

当我使用g ++ -std = c ++ 11 iter.cc -o iter编译它时,我得到了结果:

    iter.cc: In function 'int main()':
    iter.cc:63:17: error: reference to 'is_same' is ambiguous
      a_vit.set_same(is_same);
             ^
    iter.cc:37:6: note: candidates are: bool is_same(int, int)
     bool is_same(int a, int b) { return a == b; }
          ^
    In file included from /usr/include/c++/5.3.0/bits/move.h:57:0,
                     from /usr/include/c++/5.3.0/bits/stl_pair.h:59,
                     from /usr/include/c++/5.3.0/utility:70,
                     from /usr/include/c++/5.3.0/tuple:38,
                     from /usr/include/c++/5.3.0/functional:55,
                     from iter.cc:1:
    /usr/include/c++/5.3.0/type_traits:958:12: note:                         template<class, class> struct std::is_same
         struct is_same;
                ^

通过解释,我创建了一个名为'vit'的类.它做了两件事:迭代向量,并确定是否已到达新组.

类函数'set_same'应该存储由调用类提供的函数,以确定向量的两个相邻元素是否在同一组中.但是,由于is_same的表面歧义,我似乎无法将该函数存储在类中以供将来使用grp_begin()和grp_end().

是什么赋予了？

Answer 1

有一个is_same由您定义的函数,并且有一个由C++标准库is_same定义的结构.既然如此,您的编译器就不知道您打算使用哪个.using namespace stdis_same