相关疑难解决方法(0)

当涉及到"问题线"的"隐藏特征"时,没有C++的爱吗？想我会把它扔出去.C++的一些隐藏功能是什么？

我想知道C++完整概念提议和模板约束之间的语义差异(例如,Dlang中出现的约束或C++ 1y的新概念 - 精简提议).

什么是能够比模板约束做的完整概念不能做到的？

我在http://codepad.org/ko8vVCDF上编写了一个使用模板函数的示例程序.

如何将模板功能限制为仅使用数字？(int,double等)

#include <vector>
#include <iostream>

using namespace std;

    template <typename T>
T sum(vector<T>& a)
{
    T result = 0;
    int size = a.size();
    for(int i = 0; i < size; i++)
    {
        result += a[i];
    }

    return result;
}

int main()
{
    vector<int> int_values;
    int_values.push_back(2);
    int_values.push_back(3);
    cout << "Integer: " << sum(int_values) << endl;

    vector<double> double_values;
    double_values.push_back(1.5);
    double_values.push_back(2.1);
    cout << "Double: " << sum(double_values);

    return 0;
}

是否有可能强制模板来自某个基类,所以我可以调用基类函数？

template <class T>
void SomeManager::Add(T)
{
    T->CallTsBaseClassFunction();
    //... do other stuff
}

我有一个模板函数,并希望在编译时确保它没有在特定类的子类型或超类型上实例化.

如果违反此规则,如何导致C++编译器错误？

class base {
};
class derived : public base {
};
class lowest : public derived {
};

template <typename T>
bool isCorrect(const T& obj) {
  typedef foo<T> D;
  foo<T> *def = foo<T>::find();
  return (def && def->getAnswer(object));
}

我想isCorrect只上课derived,但不是base或lowest.请注意,可能有许多其他最低类和要排除的基类字符串以及可接受的替代派生类.

在C++中是否有一种方法可以将模板限制为仅应用于我明确指定的派生类？

我很难找到(我确信这是一个非常常见的)设计模式来解决以下问题.考虑一下这段代码:

class AA {};
class BB : public AA {};

class A
{
public:
    virtual void foo(AA& aa) = 0;
};

class B : A
{
public:
    void foo(BB& bb){cout<<"B::foo"<<endl;}
};

int main()
{
    B b;
    BB bb;
    b.foo(bb);
}

此代码将无法编译,因为类B不会覆盖纯虚函数'foo'.编译器认为B声明的foo仅作为foo的重载,因为覆盖函数中的输入参数中不允许使用协方差.

现在,我明白了这个的原因.B继承自A的事实意味着它应该能够使用类型AA的参数处理对foo的任何调用,并且前面的代码没有给出任何实现来处理除BB之外的任何参数类型.

当然我可以在B的foo实现中将aa转换为BB,但我正在寻找一种保留类型安全性的解决方案,并且实际上迫使B类的实现者也实现了一个继承自AA的类以便代码编译.在一个理想的世界里,我可以编写一些看起来像这个伪代码的东西:

class A
{
public:
    abstract class AA{}; //indicates that any child of A must implement also child of AA
    abstract void foo(AA& aa);
};

class B : public A
{
public:
    class BB : AA{}; //will not …

我在C++中有以下代码:

struct A;

struct B
{
    B(){}

    template<typename T>
    B(T param){}
};

我希望构造函数模板仅在typename T可转换为类型时才有效A.完成此任务的最佳方法是什么？

template <typename T>
void func(){
  T* t = new T();
  t->do_something();
  ...
}

在这种情况下,编译器如何知道typename T将在do_something()其上定义一个方法？在Java中,我们可以指定泛型类扩展的接口,但C++显然没有相同的语法.那么如果我们打电话func<AClassThatDoesntHaveDoSomethingDefined>()会怎么样？

我想用更优雅的东西替换大开关。

class Base
{
public:
  Base(void*data, int size);
  virtual void Something() = 0;
}
class A : public Base
{
public:
  A(void*data, int size) : Base(data, size) {}
  void Something() override;
}
class B : public Base
{
public:
  B(void*data, int size) : Base(data, size) {}
  void Something() override;
}
...

{
  char c = input;
  switch (c)
  {
    case 'a':
    {
      A obj(data, size);
      obj.Something();
      break;
    }
    case 'b':
    {
      B obj(data, size);
      obj.Something();
      break;
    }
    ...
  }
} …