(从上一个问题编辑,我认为下面的代码不起作用)
我希望实现一个haskell函数f,它具有一个限制,使得它的2个参数不能具有相同的类型.我使用了以下代码:
{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, UndecidableInstances, FlexibleInstances, FlexibleContexts, TypeFamilies, IncoherentInstances #-}
data HTrue = HTrue
data HFalse = HFalse
class HEq x y b | x y -> b
instance (b ~ HTrue) => HEq x x b
instance (b ~ HFalse) => HEq x y b
g :: (HEq a b HFalse) => a -> b -> ()
g x y = ()
现在函数g只接受a和b,如果它们有不同的类型.这是在haskell中编码类型不等式的"独特"方式吗？如果没有,它有什么问题？
我希望有一种类似行为boost::any但类型更有限的类型.像这样的东西:
limited_any<int,long,string> x; // x is like boost::any but is guaranteed to contain only an int, a long, or a string
您会如何推荐实施此功能？(无论是我自己还是使用现有的解决方案)
我有一个功能
class A { <has copy and move constructors > };
void f(A &&a) { ... }
我想用变量调用函数f x,但我想f在副本上运行x,而不是x自己运行.为什么我不能这样做？
f(copy(x));
但相反必须这样做
f(A(x));
有什么类似于copy我上面描述的功能吗？
注意:请不要告诉我添加一个f进行复制的重载,我想要一些不需要重载的东西并且是明确的(即向copy读者清楚说明复制是在这里完成的)
c++ generic-programming copy-constructor move-semantics c++11
如何在程序中获取malloc()的总字节数(假设我正在运行glibc)？我不想看到程序占用了多少内存,我想知道我分配了多少内存.下面是一个示例程序,其中这些数字将是非常不同的.
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
int main() {
vector<void *> p;
printf("Allocating...\n");
for (size_t i = 0; i < 1024 * 1024 * 10; ++i) {
p.push_back(malloc(1024));
memset(*p.rbegin(), 0, 1024);
}
printf("Press return to continue...\n");
getchar();
printf("Freeing all but last...\n");
for (size_t i = 0; i < p.size() - 1; ++i)
free(p[i]);
printf("Press return to continue...\n");
getchar();
// UNTIL THIS FREE, TOP WOULD SHOW THIS PROGRAM TAKES 16G,
// BUT THE TOTAL MALLOC() …以下两个声明之间有什么区别？我应该何时优先选择另一个？
void f(unique_ptr<T> x);
void f(unique_ptr<T> &&x);
在我看来,这两个都意味着f()取得了指向对象的所有权,但我看到人们都使用它们.我希望第一个是标准的,第二个被认为是一个不好的做法.
假设我有以下代码(文本<>是速记,实际上不是代码的一部分):
data A = <something>
defaultA :: A
defaultA = <Really complicated expression of type A>
现在我想要一个函数模式匹配defaultA,如下所示:
f defaultA = <case 1>
f _ = <case 2>
但是,defaultA第一行变为新变量,而不是表示参数相等的条件defaultA.我知道实现我想要的最好的方式是:
f x | x == defaultA = <case 1>
f _ = <case 2>
有谁知道更好的方法？
假设我有一个元组，t它的类型是std::tuple<T1,T2,T3>每个元组都T可以是Obj, Obj&, Obj&&, const Obj&。我想编写一个函数，将元组的值解包成一个函数f，该函数接受三种衰减到Obj. 我想尽可能避免无用的复制，我该怎么做？
我目前的实现是
static R call(C2&& c, TUP&& x) {
using TUP0 = typename std::remove_reference<TUP>::type;
return c(std::forward<typename std::tuple_element<0, TUP0>::type>(std::get<0>(x)),
std::forward<typename std::tuple_element<1, TUP0>::type>(std::get<1>(x)),
std::forward<typename std::tuple_element<2, TUP0>::type>(std::get<2>(x)));
}
但这种实现看起来move当事情TUP是std::tuple<Obj,Obj,Obj>，即使当TUP包含它应该只动Obj&&。
使用解锁的布尔值比使用std::atomic<bool>始终以宽松的内存顺序完成操作的方法有效率吗？我认为两者最终都可以编译为同一机器代码，因为单个字节实际上在X64硬件上是原子的。我错了吗？