我正在使用Bound库来表示lambda术语:
data Exp a = Var a
| Exp a :@: Exp a
| Lam (Scope () Exp a)
为了能够使用abstract并instantiate用Exp,我定义了一个单子实例:
instance Monad Exp where
return = Var
Var a >>= f = f a
(x :@: y) >>= f = f >>= x :@: f >>= y
Lam e >>= f = Lam $ e >>>= f
(>>>=在Bound中定义的位置.)
现在我想制作上述类型注释版本.我以为我会做的
data Exp a = Var a
| TypedExp a :@: TypedExp …是否有F :: * -> * -> * -> *带操作的类型构造函数的标准名称
return :: x -> F a a x
bind :: F a b x -> (x -> F b c y) -> F a c y
这是第一个参数中的逆变函子和第二个和第三个中的协变函子？特别是,这是否与类别理论中的任何类型构造相对应？
这些行动产生了一个
join :: F a b (F b c x) -> F a c x
使这看起来像某种"endofunctors类别中的类别"的操作,但我不确定如何将其正式化.
编辑:正如志所指出的,这与索引的monad有关:给定一个索引的monad
F' : (* -> *) -> (* -> *)
我们可以使用Atkey构造
data (:=) :: * -> * -> * -> *
V :: x -> (x …我试图在Ubuntu(64位)上编译以下代码,Code :: Blocks 10.05作为IDE:
#include <iostream>
using namespace std;
int main() {
char a[2];
cout << "enter ab ";
cin >> a;
if (a == 'ab') // line 7
{
cout << "correct";
}
return 0;
}
在第7行,我的编译器给出了错误"ISO C++禁止在指针和整数[-fpermissive]之间进行比较".
为什么这不起作用？我知道我可以用一个std::string来解决这个问题,但我想了解当前的问题.
N3580描述了以下场景:
template<Object T, template<Object> Cont>
struct stack {
Cont<T> container;
};
template<Object>
struct my_vector;
template<Regular>
struct my_list;
template<typename>
struct my_magic;
在这里,Regular是一个改进Object; 也就是说,每一个Regular都是一个
Object而不是每个Object都是一个Regular.
我希望类型系统是这样的,为了stack<X, Y>有效,
X必须是一个,Object并且Y必须可以实例化Object.这意味着stack<int, my_vector>并且stack<int, my_magic>有效,而stack<int, my_list>不是.与正常功能的情况非常相似:
struct Base {};
struct Derived : Base {};
void foo(Base* p, function<void(Base*)> fun) {
fun(p);
}
template<typename T>
void bar(T*);
我希望,如果p是Base* …
编译以下代码时
#include <cstring>
struct X { char a, b, c, d; };
void copy_assignment(char* p, X x) {
*p++ = x.a;
*p++ = x.b;
*p++ = x.c;
*p++ = x.d;
}
void copy_memcpy(char* p, X x) {
memcpy(p, &x, sizeof(X));
}
GCC和clang都发出一系列movb指令copy_assignment,同时发出一条movl指令copy_memcpy.假设X没有填充,它不在这里,不应该两个是等效的,并且不是单个movl更有效？
确切地说,我正在编译:
g++ -O3 -S -o prog.S prog.cpp
为了铿锵而战.GCC版本为7.1.1,Clang版本为4.0.1.使用-O2,-Os和-Ofast会得到相同的结果.
根据C++ 11标准,以下程序是否是格式良好且可移植的C++？
int main(int argc, char const* const* argv) {}
假设我有许多国家,每个国家都有许多城市.我可以使用以下模型来表示:
public class Country
{
public virtual int Id { get; set; }
[Required]
public virtual string Name { get; set; }
public virtual ICollection<City> Cities { get; set; }
}
public class City
{
public virtual int Id { get; set; }
[Required]
public virtual string Name { get; set; }
public virtual Country Country { get; set; }
public virtual int CountryId { get; set; }
}
class TestContext : DbContext
{
public DbSet<City> Cities { get; set; …我写的东西像C++的互动教程.本教程将由两部分组成:一部分编译成一个库(我使用Scons构建它),另一部分(课程)随最终用户编译的教程一起提供.我正在寻找一种方便人们建立这些课程的好方法.
基本上,第二部分是一个包含所有课程的目录,每个目录都在自己的目录中.每课至少有一个lesson.cpp和main.cpp文件,还可以存在其他文件,其中存在的我不知道,直到它被运后-最终用户将创建这些.它看起来像这样:
all_lessons/
helloworld/
lesson.cpp
main.cpp
even_or_odd/
lesson.cpp
main.cpp
calculator/
lesson.cpp
main.cpp
user_created_add.cpp
这些中的每一个都需要根据几乎相同的规则进行编译,并且编译命令应该可以从其中一个课程目录(helloworld/等等)运行.
看到项目的其余部分是使用Scons构建的,因此将它用于此部分也是有意义的.然而,使用SCons将搜索SConstruct它从运行目录下的文件:这是可以接受的把SConstruct每节课目录中的文件,再加上一个SConscript在all_lessons/给出的一般规则目录？这似乎违背了Scons期望项目组织的典型方式:这种方法的潜在缺陷是什么？我可以放一个SConstruct文件而不是SConscript文件,从而可以从任一目录构建(使用导出来避免无休止的递归,我猜)？
另外,我可能在某一时刻要替换lesson.cpp一个lesson.py生成所需的文件; Scons是否允许我轻松地与构建者一起完成这项工作,或者是否有一个更方便的框架？
最后,我想最终得到以下内容(或具有不同构建系统的等效内容):
all_lessons/
SConstruct
helloworld/
SConstruct
lesson.cpp
main.cpp
even_or_odd/
SConstruct
lesson.py
main.cpp
calculator/
SConstruct
lesson.cpp
main.cpp
user_created_add.cpp
scons all在all_lessons目录中运行需要:
even_or_odd/lesson.py生成even_or_odd/lesson.cpp.user_created_add.cpp还需要编译.运行scons中even_or_odd/,或者scons even_or_odd在all_lessons/应该产生一个可执行与上面的一个(相同的编译标志).
摘要:
我有以下代码:
template <typename T>
class ListBase
{
protected:
int _size;
public:
ListBase() {_size=0;}
virtual ~ListBase() {}
bool isEmpty() {return (_size ==0);}
int getSize() {return _size;}
virtual bool insert(int index, const T &item) = 0;
virtual bool remove(int index) = 0;
virtual bool retrieve(int index, T &item) = 0;
virtual string toString() = 0;
};
我的第二个文件定义了一个子类:
#define MAXSIZE 50
template <class T>
class ListArray : public ListBase
{//for now to keep things simple use int type only later upgrade to template …我有一些非常类似于以下内容的代码:
class C {
string s;
static C a = new C();
static void Main() {
C b = a;
b.s = "hello";
}
Main在发布模式下,该方法的反汇编如下:
C b = a;
00000000 push ebp
00000001 mov ebp,esp
00000003 push eax
00000004 cmp dword ptr ds:[04581D9Ch],0
0000000b je 00000012
0000000d call 763B3BC3
00000012 xor edx,edx
00000014 mov dword ptr [ebp-4],edx
00000017 mov eax,dword ptr ds:[01B24E20h] ; Everything up to this point
0000001c mov dword ptr [ebp-4],eax ; is fairly clear.
b.s = …