相关疑难解决方法(0)

可能重复:
是否可以编写C++模板来检查函数是否存在？

说有两个类:

struct A{ int GetInt(){ return 10; } };
struct B{ int m; };

我想在以下函数中使用类型A或B的对象

tempate< typename T >
int GetInt( const T & t )
{
   //if it's A, I'll call: return t.GetInt();
   //if its' B, I'll call: return t.m;
}

现在,因为有一大堆类,一些包含GetInt(),一些不包含,我不想为每种类型编写特化,我只想在编译时通过' 包含GetInt()来区分它们',我该怎么做？

我有一个为许多类型重载的函数.但我目前的问题是由于(LWS在这里:lws):

#include <iostream>
#include <string>
#include <sstream>
#include <type_traits>

// First version
template<typename T, class = typename std::enable_if<std::is_fundamental<T>::value>::type> 
std::string f(const T& x)
{
    return std::to_string(x);
}

// Second version
template<typename... T> 
std::string f(const std::tuple<T...>& x)
{
    return std::to_string(sizeof...(T)); // It's just an example here
}

// Third version
template<typename T, class = typename std::enable_if<!std::is_fundamental<T>::value>::type, class = void> 
std::string f(const T& x)
{
    std::ostringstream oss;
    oss<<x;
    return oss.str();
}

// Main
int main(int argc, char* argv[])
{
   std::cout<<f(42)<<std::endl;
   std::cout<<f(std::string("Hello …

我想知道是否有可能使用boost :: mpl / preprocessor或某些noce C ++ 11功能从类类型和函数名称创建函数代理。

说我们有：

  inline void set_email(const ::std::string& value);
  inline void set_email(const char* value);

内部类电子邮件。我们知道有set_email函数，我们想用API创建一个prox类，例如

PROXY(Email, set_email, MyEmail)

Email * email = new Email();
MyEmail * myEmail = new MyEmail(email);

并且有能力调用任何set_email重载。是否有可能以及如何创建这样的类来代理任何数量的不知道那里类型（仅名称）的重载函数？

我想知道是否有可能确定给定的类型是否是原子的(这意味着你可以在没有互斥的情况下对其执行操作,而不是让自己处于危险之中).

我想知道是否有一些atomic(type)定义可以确定类型是否是原子的.为了创建类似的东西DEFINE( (int)(do) );会创建伪代码,如:

   int _do;

#if !atomic(int)
    mutex do_mutex;
#endif   

   void set_do(int do)
   {
#if atomic(int)
       _do = do;
#else
       lock(do_mutex);
       _do = do;
#endif
   }

如果type是atomic(如果需要,使用boost),那么有没有办法检查define/mtl级别.

是否有等效的#ifdef来测试一个成员是否存在于类中,以便可以在不导致代码使编译器失败的情况下完成处理.我尝试过模板操作,但特定问题没有成功.

例如

#if member baseclass.memberA()
  baseclass.memberA().push_back(data);
#else
  doAlternate(data);
#endif

显然上面的内容是无效的,但我试图发现这样的东西是否已添加到C++ 11中

请注意,在初始设置中,将存在memberA,memberB,memberC,...每个都需要push_back.其他成员将来会被添加到基类中,这就是为什么我要创建一个模板,以便即使当前的基类没有某些成员(例如memberX),所有的情况都会正确编译和处理.否则,我可以使用一个非常简单的模板放入push_back()行.

这实际上是最简单的情况.还有一种情况,我创建子类的实例化,然后将其推回到子类成员.

// Instantiate an element of the Maindata class
::basedata::Maindata maindata;
//Instantiate an element of the Subdata class
::basedata::Subdata subinfo("This goes into the subinfo vector");
// Process some data that is part of the Subdata class
subinfo.contexts(contextInfo);
// Push the instantiated Subdata into the Subdata member of Maindata
maindata.subdata().push_back(subinfo);

请注意,需要设置Subdata和subdata(),以便实现适当的代码.但是,如果:: basedata :: Subdata存在,那么maindata.subdata()也是如此.

我已经尝试过使用模板的各种方法,并且特定问题无法通过收到的各种答案解决.示例是类中存在的成员的模板实例化检查,C++类成员检查(如果不是模板),变量类型声明的C++模板

关于使用别名的cppreference有一个例子.此示例失败,因为int没有成员foo:

template<typename...> using void_t = void;
template<typename T> void_t<typename T::foo> f();
f<int>(); // error, int does not have a nested type foo

这很清楚,但是当我尝试将该void_t部件放入参数列表时,它意外地编译:

template<typename...> using void_t = void;
template<typename T> void f(void_t<typename T::foo>);
f<int>();

它在clang上编译但在gcc中没编译.这是一个错误吗？

我想要一个接受不同类型参数的泛型函数(或方法).如果提供的类型具有"one"方法,则该函数应使用它.如果它有'两个'方法,该函数应该使用它.

这是无效的代码:

#include <iostream>

template<typename Type> void func(Type t)
{
    t.one();
}

template<typename Type> void func(Type t) // redefinition!
{
    t.two();
}

class One
{
    void one(void) const
    {
        std::cout << "one" << std::endl;
    }
};

class Two
{
    void two(void) const
    {
        std::cout << "two" << std::endl;
    }
};

int main(int argc, char* argv[])
{
    func(One()); // should print "one"
    func(Two()); // should print "two"
    return 0;
}

是否可以使用SFINAE？是否可以使用type_traits？

澄清:

如果可以使用SFINAE,我会更高兴.最好的情况是:使用第一个模板,如果失败则使用第二个模板.

检查方法存在只是一个例子.我真正想要的还是检查与其他类的兼容性.

任务可以改写:

1. 如果该类支持第一个接口,请使用它.
2. 如果第一个接口出现故障,请使用第二个接口.
3. 如果两者都失败,则报告错误.

可能重复:
C++模板可以检查函数是否存在？

我试图确定一个类型有某个成员.这是我试过的:

template <typename T,typename U=void>
class HasX
{
public:
    static const bool Result=false;
};

template <typename T>
class HasX<T,typename enable_if_c<(sizeof(&T::X)>0)>::type>
{
public:
    static const bool Result=true;
};


struct A
{
    int X();
};

struct B
{
    int Y();
};


int main()
{
    cout<<HasX<A>::Result<<endl; // 1
    cout<<HasX<B>::Result<<endl; // 0
}

它实际上是在GCC上编译和工作,但VC error C2070: 'overloaded-function': illegal sizeof operand在实例化时提供.

代码是否有问题,是否有其他方法可以做到这一点？

我想要的语义与std::remove_pointer真指针相似但可用于指针类的东西。我自然可以列举出已知的可能性：

// Important: remove_pointer_ex<T>::type should evaluate to T
// if T::operator* is not defined (like std::remove_pointer)
template<typename T> struct remove_pointer_ex { typedef T type; };

template<typename T> struct remove_pointer_ex<T*> { typedef T type; };
template<typename T> struct remove_pointer_ex<std::shared_ptr<T>> { typedef T type; };
template<typename T> struct remove_pointer_ex<std::unique_ptr<T>> { typedef T type; };
// and then again for all the different cv combinations

但我真的很想一种可以与任何支持类一起使用的方法operator*。

看起来这应该可以使用SFINAE和/或类型特征来实现。这个问题的答案描述了如何测试特定类型是否具有特定成员，我想我可以结合使用这些建议之一enable_if，但是坦率地说，如果没有不那么丑陋的方法来解决问题，我宁愿只是尝试一种完全不同的方法。

I\xc2\xb4ve 遇到了一个函数声明，例如：

int vsa_d(...);\n

和...一个且唯一的参数。

我知道通过省略号，我们可以指代多个对象，但是指代的是什么？...这里指的是什么呢？

\n

• 这意味着什么以及它的目的是什么？

\n

• 到什么...编译器评估

\n

• 在调用函数时，省略号也可以用作函数参数吗？

\n

我\xc2\xb4ve在“注释”下找到了https://en.cppreference.com/w/cpp/language/variadic_arguments：