相关疑难解决方法(0)

这个问题的灵感来自以下多重继承重载伪歧义的解决方案,这是一个很好的方法来实现此答案中提出的boost :: variant的lambda访问者:

我想做类似以下的事情:

template <typename ReturnType, typename... Lambdas>
struct lambda_visitor : public boost::static_visitor<ReturnType>, public Lambdas... {
    using Lambdas...::operator(); //<--- doesn't seem to work
    lambda_visitor(Lambdas... lambdas) : boost::static_visitor<ReturnType>() , Lambdas(lambdas)... { }
};

我不确定在打包类型列表中添加使用子句的正确语法是什么.该using条款对于阻止编译器抱怨operator()模糊不清是完全不重要的,因为它们具有所有不同的签名.

我最近开始使用C++ 11,我已经阅读了关于可变参数模板的教程.我已经明白我们可以像这样定义一个可变参数模板

// example class that uses variadic template
template<typename ...Args> struct mtuple;

但是我如何处理类的模板参数mtuple(即get<int>(mtuple_obj)外观如何？)？

我在我的一个类中使用gcc 3.4.5(mingw)得到以下编译错误:

src/ModelTester/CModelTesterGui.cpp:1308: error: request for member `addListener' is ambiguous
include/utility/ISource.h:26: error: candidates are: void utility::ISource<T>::addListener(utility::IListener<T>*) [with T = const SConsolePacket&]
include/utility/ISource.h:26: error:                 void utility::ISource<T>::addListener(utility::IListener<T>*) [with T = const SControlPacket&]

希望你能看到这ISource<T>是一个模板接口,它只是表明该对象可以是某个匹配类型的对象的informer IListener<T>.让我烦恼的是这个想法,由于某种原因,功能是模棱两可的,据我所知,它们不是.addListener()对于不同的输入类型IListener<const SConsolePacket&>,该方法会被重载IListener<const SControlPacket&>.用法是:

m_controller->addListener( m_model );

m_model指向IRigidBody对象的指针在哪里,并且IRigidBody仅从,IListener< const SControlPacket& >并且绝对不是从IListener< const SConsolePacket& >

作为一个完整性检查,我使用doxygen来生成类层次结构图,并且doxygen同意我的IRigidBody不同意IListener< const SConsolePacket& >

显然,我对c ++中的继承性的理解并不完全正确.我的印象是IListener<const SControlPacket&>,它IListener<const SConsolePacket&>是两种不同的类型,而且是函数声明

addListener(IListener<const SConsolePacket&>* listener)

和 …

我理解使用可变参数模板参数的递归性质和特定模板实例化的基本概念,逐个"吃"我的方式通过参数列表.

我知道lambdas可以编写为采用某些类型然后返回某些类型.请记住,我还在学习C++ 14和C++ 11,所以我还没有掌握其中的一个.

这是我在查看其他 Stack Overflow问题后的尝试:

// For std::string
#include <string>

// For std::cout
#include <iostream>


//Create a generalized list instantiation
template <typename ... F>
struct overload : public F... {
    overload(F... f) : F(f)... {}
};      

//Create an specific end-case, where we directly
//inherit the () operator in order to inherit
//multiple () overloads
template <typename F>
struct overload : F {
    using F::operator();
};


//template function to create an overload
template <class... F>
auto make_overload(F... …

我想在不实现类的情况下使用lambdas实现多态访问者.我已经有了一个基础,但我正在为我的lambdas参数的类型演绎而苦苦挣扎.

假设我有一些遗留代码库,决定使用类型标签作为多态类型,如下所示:

enum class ClassType
{
    BaseType = 0, TypeA, TypeB
};

class BaseType
{
public:
    virtual ~BaseType() {}
    ClassType getType() const
    { return type; }

protected:
    ClassType type;
};

class TypeA : public BaseType
{
public:
    static const ClassType Type = ClassType::TypeA;
    explicit TypeA(int val) : val(val)
    { type = ClassType::TypeA; }
    virtual ~TypeA() {}

    int val;
};

class TypeB : public BaseType
{
public:
    static const ClassType Type = ClassType::TypeB;
    explicit TypeB(std::string s) : s(s)
    { type = …

我需要在向量中存储两种类型的对象,这两种类型几乎没有任何共同之处.

将它们存储在向量中之后,我想迭代该向量并执行操作,具体取决于类型.

到目前为止我的想法:

• 多态性.矫枉过正,对我帮助不大,因为我可能会这样做:

  if(dynamic_cast<T1>() != nullptr) {
      ...
  } else {
     ...
  }
  

  Run Code Online (Sandbox Code Playgroud)

• 合并两种类型(方法和字段)并添加一个布尔值,表示其类型1或2.

这两种模式对我来说都显得十分笨拙,有一个完全简单的解决方案,我根本就看不到.

第一种类型是这样的:

struct PatternMatch {
  int length;
  int indexInDict;
}

第二个:

struct NoMatch {
  std::string rawChars;
}