标签: generic-programming

有一个泛型函数LanguagePrimitives.DivideByInt可以在int不丢失泛型行为的情况下进行除法,我们可以像这样使用它:

let inline Divideby2 n = LanguagePrimitives.DivideByInt n 2

val inline Divideby2 :
    ^a ->  ^a when  ^a : (static member DivideByInt :  ^a * int ->  ^a)

但是没有被称为MultiplyByInt执行泛型乘法的函数int.有没有什么可以执行泛型乘法？像这样:

let inline MultiplyBy2 n = SomeGenericFunctionsModule.MultiplybyInt n 2;

PS我们总是可以使用一些非标准方法,如:

let inline MultiplyByInt n m = seq { for i in 1..m -> n} |> Seq.sum

但我很有兴趣是否有可能以正确的方式做到这一点.

我正在编写一个平均每10个100单位向量单位的函数.我必须在每10次迭代后清除一个临时总和.通常,我会写,ave=0.0但如果ave不是一个双重但有些类型T,我遇到了问题.例如,如果我用xyz坐标平均得分,s我就做不到{x,y,z} = 0.0

为了解决这个问题,我尝试创建一个智能指针,然后重置它.这给了我一个错误.清除没有指定类型的对象的最佳方法是什么？

template <class T>
vector<T> average(const vector<T> &v, const int n) {
  vector<T> ave_vec;
  int iave = 0;
  shared_ptr<T> ave(new T);
  for (int i = 0; i < v.size(); i++) {
    *ave += v[i];
    iave++;
    if (iave == n) {
      ave_vec.push_back(*ave/n);
      ave.reset(); ///> gives seg fault
      iave=0;
    }
  }
  return ave_vec;
}

如果我更换ave.reset()用ave = 0.0,代码工作.

在C++中,您可以将指针声明为一种类型,然后将其指向另一种继承类型.有什么方法可以告诉你当前指的是哪个？

#include <typeinfo>
using namespace std;

class Foo
{
};

class Bar : public Foo
{
};

int main()
{
    Bar bar;
    Foo* foo = &bar;
    bool I_WANT_THIS_TO_BE_TRUE = (typeid(*foo) == typeid(Bar));
    return 0;
}

在这段代码中,为什么typename T(在Test(...)函数中)评估为键入Foo而不是类型Bar？我怎样才能改变它以使它成为Bar型？

#include <typeinfo>
using namespace std;

struct Foo
{
    virtual ~Foo() { }
};

struct Bar : public Foo
{
};

template<typename T>
bool Test(T foo)
{
    return (typeid(foo) == typeid(Bar));
}

int main()
{
    Bar bar;
    Foo *foo = &bar;
    bool THIS_IS_TRUE = (typeid(*foo) == typeid(Bar));
    bool WHY_ISNT_THIS = Test(*foo);
    return 0;
}

如何创建一个行为如此的函数？我似乎无法正确声明返回类型.

template <typename C, typename T0, typename T1>
typename C<T1> 
convert_container(const C<T0>& container, T1 value) {
  C<T1> new_container;
  // Do some stuff...
  return new_container;
}

std::vector<int> vec0;
const auto& vec1 = convert_container(vec0, float(2.0f)); // Produce a vector of floats

std::list<int> lst0;
const auto& lst1 = convert_container(lst0, float(2.0f)); // Produce a list of floats

Guava具有通用分区方法，由于Go缺乏通用属性，因此无法直接在Go中实现。有没有解决方法？

是否有可能在一个表达式中获取表达式(或标识符)的字符串表示template？例如,拥有下一个代码:

template `*`*(name: expr) {.immediate.} =
  var `name`* {.inject.}: string = ""
  # Want to print 'name' here, not its value like with backticks

是否可以name在模板中获取表达式的字符串表示形式？

在C++ 2003中,typedef只能用于完整类型.因此,不允许创建指向函数的指针和通用T作为类型:

template <typename T>
typedef T(*f_function)(T, T, T);

有没有办法如何使用语法在C++ 2003或C++ 0x中回避这个问题

using (*f_function)(T, T, T); // something like that

我想使用指向函数fff的指针作为类成员

template <typename T>
class A
{
public:
    f_function fff;

    A() {fff = NULL;}
    A( f_function pf){fff = &pf;}
};

template <typename T>
T f1(T x, T y, T z) {   return x + y + z;}

template <typename T>
T f2(T x, T y, T z) {   return x - y - z;}

并在构造函数中初始化其值.随后:

int main()
{
A <double> …

我需要创建一个可以在变量中存储类型值的类Person,Dog或者Cat.

我想声明一个变量,因为只有一个特定类型的对象将用于初始化类的实例.为每种类型声明一个变量将浪费资源,因为只使用一个.

考虑一下:

Class Container {
    private Object object;
    ...
    Container(Person a){
        object = a;
    }
    Container(Dog a){
        object = a;
    }
    Container(Cat a){
        object = a;
    }
    ...
}

然后做:

Container contA = new Container(A);
Container contB = new Container(B);

System.out.println(contA.getObject().toString());
System.out.println(contA.getObject().toString());

理想情况下,在控制台中获得正确的输出.

我研究了仿制药和其他东西,但却无法找到我需要的东西.你能指点我正在找的东西吗？

在getObject()中Container能与处理的类型instanceof,但返回类型getObject()必须是Object而且将无法正常工作.

我正在学习Java,这真的让我烦恼.

我应该使用继承并创建一个子类来处理每种类型吗？

我正在尝试创建一个抽象数据模型，在该模型中我传递数据并键入a，然后是返回列表，但是当我无法调用T.fromJson()方法时，请注意传递类型具有方法fromJson()

class DataList<T> {
  final bool success; 
  dynamic data;


  InfosResponse({
    this.success,
    List<dynamic> data,   
  }) {
    castDataToList(data);
  }

  factory DataList.fromJson(Map<String, dynamic> json) {
    return DataList(
      success: json['success'],
      data: json['data'],
    );
  }

  void castDataToList(jsonData) {
    this.data = List<T>.from(jsonData.map((x) => T.fromJson(x)));
  }
}