标签: generic-programming

我创建了一个泛型类，但我知道运行时的类型，而不是设计中的类型，所以我想知道如何在运行时设置类型。

例如，我有：

public class MyGenericClass<T>
{
....
}

然后我尝试使用它。我在其他类中有一个方法，它使用这个通用类。在这个类的构造函数中，我接收我想要的类型作为参数，所以我有一个类型属性，我可以在其中保存我需要的类型。所以我正在尝试这个：

MyGenericClass<_typeNeeded> myClass = new MyGenericClass<typeNeeded>();

但这不起作用。

如何在我创建的类中在运行时设置类型？

我正在使用 C# 4.0。

谢谢。戴姆洛克。

编辑：我想做的是以下内容。我有一个类需要对数据库进行一些查询。这个查询总是返回相同的信息，一个类，但是包含这个类的信息来自不同的表。这是因为我需要确定要使用的查询。为了决定使用什么查询，我使用我收到的类型。

正是因为这个原因，我不知道设计类型，但在运行时。

我可以使用一个由类实现的接口，并使用用正确的类实例化的接口，但这使我在实例化的时候有一个开关或一个 if，这是我试图避免的，我想要更通用的东西。另外，如果我使用这个解决方案，在实例化的那一刻有一个 if，我可以创建泛型类，所以我只有一个类，它会更易于维护。

我正在尝试创建一个通用容器，它可以存储 Wrapper< T> 类型的异构对象，其中 T 可以是任何用户定义的类型。我已经看到了 boost::any 和其他解决方案，但我不能在不重铸的情况下调用函数 foo()（我不知道要重铸哪种类型，关于 T 的信息丢失了。）它回到原始类型。

我怎样才能合理地实现一个通用容器/使用现有的通用容器来实现这一点？

template <typename T>
class Wrapper{
public:
  Wrapper(const T& a):o(a){};
  Wrapper(){};
  //public methods
  void foo(){
     //do stuff
  };
private:
 T o;
};

class X{};
class Y{};

int main(){
  X x;
  Y y;

  A_GENERIC_CONTAINER generic_container;
  // A_GENERIC_CONTAINER should be able to store
  // any number of heterogeneous objects of type Wrapper<T>
  // where T can be any user defined type.

  generic_container.push_back(x);
  generic_container.push_back(y);

  auto it =  generic_container.begin();
  auto end =  generic_container.end(); …

我认为我的问题是,我将我对Haskell多态性的非常有限的知识与其他语言的重载和模板等问题混为一谈.在我之前的问题之后,我认为我对这些概念有了更好的把握,但是再次尝试过,我猜不是!

无论如何,我正在尝试实现通用距离函数.这很简单:

euclidean :: Integral a => [a] -> [a] -> Double
euclidean a b = sqrt . sum $ zipWith (\u v -> (u - v)^2) x y
                where x = map fromIntegral a
                      y = map fromIntegral b

现在我想将它应用于两种向量类型(为了参数,不能重新定义):

type Vector1 = Integer
data Vector2 = Vector2 Integer Integer

在阅读上一个问题的答案后,我想我会选择模式匹配:

d :: a -> a -> Double
d (Vector2 x1 y1) (Vector2 x2 y2) = euclidean [x1, y1] [x2, y2]
d a b = …

一个受欢迎的图书馆的作者决定实施以下设计模式:

// my_traits.hpp
#include <stdio.h>
#include <assert.h>

template<typename T>
struct my_traits {
        static bool equals(const T& x, const T& y) {
                printf("base\n");
                return x == y;
        }
};

template<typename T>
void my_assert(const T& x, const T& y) {
        assert(my_traits<T>::equals(x, y));
}

现在假设库使用如下:

// main.cpp
void my_test1();
void my_test2();

int main() {
        my_test1();
        my_test2();
        return 0;
}

和

// my_test1.cpp
#include "my_traits.hpp"

void my_test1() {
        my_assert(-1.0, -1.0);
}

和

//my_test2.cpp
#include "my_traits.hpp"

#ifdef _WIN32
#include <float.h>
#define …

我在为以下代码找到合适的类型约束时遇到问题

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
import GHC.Generics

data Value = One | Two deriving Generic

class Class a where
    cname :: a -> String -> Bool
    default cname :: (Generic a, GClass (Rep a))
               => a -> String -> Bool
    cname = gname . from

class GClass f where
    gname :: f a -> String -> Bool

instance GClass (f :+: g) where
    gname (L1 x) s | …

例如,在以下代码中

public <U extends Number> void inspect(U u){
// Some method
}

返回类型之前的目的是什么(该行正在做什么或如何读取)

我在Scala中遇到类声明问题:

   class Class2[
      A,
      B <: Class2[A,B,C],
      C <: Class3[A,C]
   ]


   class Class3[
      A,
      C <: Class3[A,C]
   ]

   class Class1[
      A, 
      B <: Class2[A,B,C], 
      C <: Class3[A,C]
    ](obj : B) { ... }

它是正确的声明,但每次我想创建该类的实例时,我需要手动指定参数A和C. 喜欢:

val X = Class1[Type1, Type2, Type3](correct_object_of_Type2)

如果我尝试val X = Class1(OBJ)它会导致错误...types [Nothing, B, Nothing] do not conform to [A, B, C]...

为什么Scala不从B推断出类型A和C？以及如何为Scala编译器声明类,以便它能够自己指定A,C？谢谢

编辑

我很抱歉配方,原来的任务是正确定义Class1,如:

   class Class2[
      A,
      B <: Class2[A,B,C],
      C <: Class3[A,C]
   ]


   class Class3[
      A,
      C <: Class2[A,C]
   ]

   ??class Class1(obj …

我想要做的是取一个指向的字符串argv[1]并将其复制到另一个数组,但我希望这个新数组是const.

有没有办法将数组声明为const并使用argv[1]同一行的内容初始化它？

我遇到的问题是我无法将其声明为const然后在下一行使用strcpy或某些此类函数复制字符串.那是无效的.

什么是最好的行动方案？

我试图了解如何在Rust中实现一般特征.

虽然我已经看过很多例子,但这些例子与特定用途(例如基因组变异器)过于紧密联系,因此我能够在Rust开发过程中理解这一点.

相反,这是一个基于相当普遍的东西的简单示例 - 递增:

trait Incrementable {
    fn post_inc(&mut self) -> Self;
    fn post_inc_by(&mut self, n: usize) -> Self;
}

impl Incrementable for usize {
    fn post_inc(&mut self) -> Self {
        let tmp = *self;
        *self += 1;
        tmp
    }

    //"Overload" for full generalizability
    fn post_inc_by(&mut self, n: usize) -> Self {
        let tmp = *self;
        *self += n;
        tmp
    }
}

fn main() {
    let mut result = 0;
    assert!(result.post_inc() == 0);
    assert!(result == 1);

    assert!(result.post_inc_by(3) …

我在玩Haskell的Data和Typeable，并且一直在尝试获取函数的参数而上下文中没有类型变量。

让我澄清一下我的意思。只要我按a如下方式量化类型变量，就可以使用fromConstr并获得DataType或TypeRep希望的列表：

constrArgs :: forall a. Data a => Constr -> [DataType]
constrArgs c = gmapQ f (fromConstr c :: a)
  where f :: forall d. Data d => d -> DataType
        f _ = dataTypeOf @d undefined

（我认识到undefined和fromConstr并非总和，但懒惰在这里为我们节省了费用。）

但是，如果我尝试避免量化a，则无法再对的结果进行类型归因fromConstr。我想知道是否有一种方法可以编写具有以下类型签名的函数：

constrArgs' :: Constr -> [DataType]

我的最终目标是编写一个函数，该函数给出DataTypes列表的列表，每个构造函数的子列表，每个子列表均包含该构造函数的参数类型。使用第一个版本，编写带有类型签名的函数并不困难：（取消定义）

allConstrArgs :: forall a. Data a => [[DataType]]

问题是我无法应用于allConstrArgs自身的结果，因为没有办法将其DataType …