相关疑难解决方法(0)

我试图找到关于模板关键字的任何信息用作消除歧义,但没有任何相关信息.可能我正在搜索错误的关键字,但标准中没有.template或 - >模板.谷歌只显示来自不同论坛的GCC问题,但没有真正解释它用于什么.

第11行(在GCC上)没有模板关键字编译的代码无法编译,但我不太确定这是否符合标准.

template<typename B>
struct S1
{
    template<typename T> void test() {}
};

template<typename T>
struct S2
{
    S2()
    {
        S1<T>().template test<int>();
    }
};

int main()
{
   S2<int>();
}

所以我的问题是:为什么这里使用了模板关键字,没有那个关键字会有什么样的歧义？我在哪里可以阅读(我非常感谢链接到标准).

谢谢.

我正在尝试编写一个带有重载构造函数的类,它接受std :: function对象作为参数,但当然每个该死的东西都可以隐式地转换为任何签名的std :: function.这自然是非常有用的.

例:

class Foo {
  Foo( std::function<void()> fn ) {
    ...code...
  }
  Foo( std::function<int()> fn ) {
    ...code...
  }
};

Foo a( []() -> void { return; } );    // Calls first constructor
Foo b( []() -> int { return 1; } );   // Calls second constructor

这将无法编译,抱怨两个构造函数基本相同且含糊不清.当然,这是无稽之谈.我尝试过enable_if,is_same和其他一些东西.接受函数指针是不可能的,因为这会阻止有状态lambda的传递.当然必须有办法实现这一目标吗？

我害怕,我的模板技能有点缺乏.普通的模板类和函数很容易,但使用编译器玩傻傻的玩家有点超出了我的联盟.有人可以帮帮我吗？

我之前已经知道这个问题的变体,但它们通常关注的是正常的函数而不是构造函数; 或者通过参数而不是返回类型进行重载.

我正在尝试使用gcc 4.2在Linux上编译以下代码:

#include <map>
#include <list>

template<typename T>
class A
{
...

private:
    std::map<const T, std::list<std::pair<T, long int> >::iterator> lookup_map_;
    std::list<std::pair<T, long int> > order_list_;

};

当我编译这个类时,我从gcc收到以下消息:

error: type/value mismatch at argument 2 in template parameter list for ‘template<class _Key, class _Tp, class _Compare, class _Alloc> class std::map’
error:   expected a type, got ‘std::list<std::pair<const T, long int>,std::allocator<std::pair<const T, long int> > >::iterator’
error: template argument 4 is invalid

我删除了文件名和行号,但它们都引用了声明地图的行.

当我用int或某些具体类型替换这些表达式中的对时,它编译得很好.有人可以向我解释我做错了什么.

可以编译以下代码而不会出现错误:

template <typename T> struct A {
    void f() { this->whatever; } // whatever is not declared before
};
int main() {
    A<int> a;
}

我知道这是因为this是一个依赖于类型的表达式,它使名称查找whatever被推迟,直到知道实际的模板参数.由于f()在这种情况下从不使用成员函数,因此不A<T>::f存在实例化,并且whatever永远不会执行名称查找.

我可以理解,this如果类模板具有依赖于类型的基类,那么它是类型相关的:

template <typename T> struct B { T whatever; };
template <typename T> struct A : B<T> {
    void f() { this->whatever; }
};
int main() {
    A<int> a;
}

在解析模板类的定义时A,不可能知道它的基类是什么,这使得this->whatever潜在合法(B<T>可能有一个成员命名whatever).相反,this->whatever一旦在f …

struct A
{
    template<int>
    void foo()
    {}
};

int main()
{
    A a;
    a.foo<0>(); // ok
    a.template foo<0>(); // also ok
}

显然,比起来a.foo<0>();更简洁,直观和富有表现力a.template foo<0>();.

为什么C++允许a.template foo<0>();即使a.foo<0>();足够了？

我有以下代码：

template <typename TC>
class C
{
    struct S
    {
        template <typename TS>
        void fun() const
        {}
    };

    void f(const S& s)
    {
        s.fun<int>();
    }
};

// Dummy main function
int main()
{
    return 0;
}

当使用 gcc 9.2 和 clang (9.0) 构建它时，由于template调用fun. Clang 显示：

error: use 'template' keyword to treat 'fun' as a dependent template name
        s.fun<int>();
          ^
          template 

我不明白为什么编译器认为fun是 上下文中的依赖名称f，因为f它本身不是模板。如果我改为C普通类而不是模板，错误就会消失；但是，我不明白为什么首先应该出现错误，因为既不S也不f依赖于TC. …

我不敢相信gcc不会接受以下代码...请告诉我,如果从基本模板访问内部类是真的不可能或我错过了什么？

template <class T> class BaseClass
{
public:
    struct MyStruct
    {
        T *data;
    };
};

template <class T> class ChildClass : public BaseClass <T>
{
    public:

    void problem()
    {
        MyStruct ms1; //error: 'MyStruct' was not declared in this scope
        ::MyStruct ms2; //error: '::MyStruct' has not been declared
        BaseClass<T>::MyStruct ms3; //error: expected `;' before 'ms3'
    }
};

在C++中,我试图std::vector::iterator为我的模板化课程.但是,当我编译它时,我得到错误:error C2146: syntax error : missing ';' before identifier 'iterator',error C4430: missing type specifier - int assumed. Note: C++ does not support default-int.我也收到警告warning C4346: 'std::vector<T>::iterator' : dependent name is not a type:

#include <vector>
template<class T> class v1{
    typedef std::vector<T>::iterator iterator; // Error here
};
class v2{
    typedef std::vector<int>::iterator iterator; // (This works)
};

我甚至试过了

template<typename T> class v1{
    typedef std::vector<T>::iterator iterator;
};

和

template<typename T = int> class v1{
    typedef std::vector<T>::iterator …

这个问题用了is_same<uint64_t, decltype(val)>::value.

我希望那里是一个C++ 14 using alias:is_same_v类似于助手类型:conditional_t,enable_if_t,和tuple_element_t我在用我的答案.因为我唯一能使用这些功能的是获得type.所以*_t助手才有意义.

这让我想到了我的问题,为什么using alias is_same_vC++ 14中没有？我唯一使用is_same的是它value.也许is_same通常不用于模板声明？

我在另一个模板类中有一个以下嵌套模板类:

template<typename T>
struct A
{
    template<typename V>
    struct B {};
};

operator==嵌套类型的非成员的签名是B什么？以下天真的尝试不起作用:

template<typename T, typename V>
bool operator==(A<T>::B<V> left, A<T>::B<V> right);

Clang,GCC和MSVC提供了各种不同的错误和/或提示错误,例如缺少template关键字,但我没有尝试解决它.

请注意,这显然有效:

template<typename T>
struct A
{
    template<typename V>
    struct B {};

    template<typename V>
    friend bool operator==(B<V> left, B<V> right)
    {
        return true;
    }
};

但是,我需要外部非成员声明的原因是使用qdoc记录它.qdoc正在使用clang来解析源代码,它要求我提供operator==我实际已经实现的声明,就像刚刚显示的那样.

现场演示