如何实现Numeric [T]的子类型？我一直在寻找这方面的指南,但没有找到任何.子类型的例子可能是Rational还是Complex？
在此先感谢Troels
模板模板规范是这样的:
template < template < class > class T >
struct MyTemplate
{
};
我该如何为这个模板创建一个全部(或部分)专业化？这可能吗？
我写了函数来找到最长的公共子序列(LCS).例如,对于两个字符序列BANANA和ATANA,它返回AANA.实现是递归算法的天真低效适应,但它与此问题的目的无关.
def LCS[T](a: Seq[T], b: Seq[T]): Seq[T] = {
if (a.isEmpty || b.isEmpty)
Seq.empty
else if (a.head == b.head)
a.head +: LCS(a.tail, b.tail)
else {
val case1 = LCS(a.tail, b)
val case2 = LCS(a, b.tail)
if (case1.length > case2.length) case1 else case2
}
}
我想以最通用的方式重构此函数.当前实现适用于任何类型的输入序列,但始终返回List [T]类型的集合.我想实现以下行为:
LCS(List('B','A','N','A','N','A'), List('A','T','A','N','A')) -> List('A','A','N','A')
LCS(Vector('B','A','N','A','N','A'), Vector('A','T','A','N','A')) -> Vector('A','A','N','A')
...and so on for all other Seqs...
如果LCS也可以处理String和Array,那将是很棒的:
LCS("BANANA", "ATANA") -> "AANA"
LCS(Array('B','A','N','A','N','A'), Array('A','T','A','N','A')) -> Array('A','A','N','A')
我相信在Scala …
我正在尝试编写一些通用结构.基本上,我需要的是C++模板,但由于我是用C语言编写的,因此不考虑模板.目前我正在考虑实现我想要的两种方式.
方法1:使用预处理器.像这样:
#define DEFINE_PAIR(T) typedef struct Pair_##T{ \
T x; \
T y; \
} Pair_##T
DEFINE_PAIR(int);
int main(){
Pair_int p;
return 0;
}
一个明显的缺点是你必须在使用类型之前调用宏.可能还有更多的缺点,我希望你能指出.
方法2:只使用void-pointers,如下所示:
typedef struct Pair{
void* x;
void* y;
} Pair;
显然,这种方法不是类型安全的(我可以轻松地将一对字符串传递给期望一对双精度的函数),而且使用这种方法进行重新分配的代码变得更加混乱.
我想听听你对此的看法.这两种方法中哪一种更好/更差？为什么？有没有其他方法可以用来在C中编写通用结构？
谢谢.
template<typename T>
struct foo{
void f(){
decltype(*this) a(*this);
do_some_test(a);
}
T data;
};
//compiler won't accept this
在我的解释中,decltype应该返回一个类型,以便我们可以在声明中使用它.但谷歌表示,在decltype(x),如果x是一个左值,它将返回T&这里T是x的类型.
但他们设计的是什么来返回参考？此外,我应该怎么做才能创建与*this模板中的类型相同的类的实例？
我正在阅读C++入门并看到这两个似乎具有相同功能的函数.谁能帮忙告诉我两者有什么区别？谢谢.
是否有任何特征指定一些数字功能？我想用它来绑定泛型类型,就像这个假设HasSQRT:
fn some_generic_function<T>(input: &T)
where T: HasSQRT
{
// ...
input.sqrt()
// ...
}
有没有办法只为基本类型制作模板专业化？我试图做以下事情:
template<typename T, typename = typename std::enable_if<!std::is_fundamental<T>::value>::type>
class foo
{
}
template<typename T, typename = typename std::enable_if<std::is_fundamental<T>::value>::type>
class foo
{
}
但我收到一个错误,模板已经定义.
因此,有一种被称为"折叠的普遍属性"的东西,完全如下:
g [] = i; g (x:xs) = f x (g xs) <=> g = fold f i
但是,正如您现在可能的那样,有一些罕见的情况dropWhile,fold f i 除非您将其概括,否则无法重新定义.
最简单但最明显的推广方法是重新定义通用属性:
g' y [] = j y; g' y (x:xs) = h y x xs (g' y xs) <=> g' y = fold (?) l
在这一点上,我可以做出我的假设:我假设存在某种功能p :: a -> b -> b,这将满足等式g' y = fold p l.让我们尝试用普遍属性帮助解决给定的方程式,一开始就提到:
g' y [] = j y = fold p l [] = l …haskell functional-programming proof generic-programming fold
在Rust中提供通用关联类型之前会询问此问题,尽管它们是提出并开发的.
我的理解是,特质泛型和相关类型在它们可以绑定到结构的类型数量上有所不同.
泛型可以绑定任意数量的类型:
struct Struct;
trait Generic<G> {
fn generic(&self, generic: G);
}
impl<G> Generic<G> for Struct {
fn generic(&self, _: G) {}
}
fn main() {
Struct.generic(1);
Struct.generic("a");
}
关联类型只绑定1种类型:
struct Struct;
trait Associated {
type Associated;
fn associated(&self, associated: Self::Associated);
}
impl Associated for Struct {
type Associated = u32;
fn associated(&self, _: Self::Associated) {}
}
fn main() {
Struct.associated(1);
// Struct.associated("a"); // `expected u32, found reference`
}
通用关联类型是这两者的混合.它们绑定到一个类型正好相关的1个生成器,而这个生成器又可以关联任意数量的类型.那么Generic前一个例子与这个通用关联类型有什么区别？ …