小编Pub*_*bby的帖子

我想static const char在班上有一个数组.海湾合作委员会抱怨并告诉我应该使用constexpr,虽然现在它告诉我这是一个未定义的参考.如果我使数组成为非成员,那么它将编译.到底是怎么回事？

// .hpp
struct foo {
  void bar();
  static constexpr char baz[] = "quz";
};

// .cpp
void foo::bar() {
  std::string str(baz); // undefined reference to baz
}

我很好奇为什么Haskell实现使用GC.

我想不出一个纯语言需要GC的情况.它只是减少复制的优化,还是实际上是必要的？

我正在寻找在GC不存在时会泄漏的示例代码.

struct _USBCHECK_FLAGS
    {
        unsigned char   DEVICE_DEFAULT_STATE       : 1;
        unsigned char   DEVICE_ADDRESS_STATE       : 1;
        unsigned char   DEVICE_CONFIGURATION_STATE : 1;
        unsigned char   DEVICE_INTERFACE_STATE     : 1;
        unsigned char   FOUR_RESERVED_BITS         : 8;
        unsigned char   RESET_BITS                 : 8;
    } State_bits;

是什么:1和:8意味着什么？

我不明白为什么在下面的代码中,当我实例化一个类型的对象时daughter,默认的grandmother()构造函数被调用？

我认为grandmother(int)应该调用构造函数(遵循我的mother类构造函数的规范),或者由于虚拟继承,这个代码根本不应该编译.

这里编译器grandmother在我的后面静默调用默认构造函数,而我从来没有要求它.

#include <iostream>

class grandmother {
public:
    grandmother() {
        std::cout << "grandmother (default)" << std::endl;
    }
    grandmother(int attr) {
        std::cout << "grandmother: " << attr << std::endl;
    }
};

class mother: virtual public grandmother {
public:
    mother(int attr) : grandmother(attr) {
        std::cout << "mother: " << attr << std::endl;
    }
};

class daughter: virtual public mother {
public:
    daughter(int attr) : mother(attr) {
        std::cout << "daughter: " << …

我想写一个简单的加法器(giggles),它将每个参数相加并返回一个具有适当类型的和.目前,我有这个:

#include <iostream>
using namespace std;

template <class T>
T sum(const T& in)
{
   return in;
}

template <class T, class... P>
auto sum(const T& t, const P&... p) -> decltype(t + sum(p...))
{
   return t + sum(p...);
}

int main()
{
   cout << sum(5, 10.0, 22.2) << endl;
}

在GCC 4.5.1上,这似乎适用于2个参数,例如sum(2,5.5)返回7.5.但是,由于参数多于此,我得到的错误是sum()尚未定义.如果我这样声明sum():

template <class T, class P...>
T sum(const T& t, const P&... p);

然后它适用于任意数量的参数,但sum(2,5.5)将返回整数7,这不是我所期望的.有两个以上的参数我假设decltype()必须进行某种递归才能推导出t + sum(p ...)的类型.这是合法的C++ 0x吗？或者decltype()仅适用于非可变参数声明吗？如果是这样的话,你会怎么写这样的功能？

我的C++项目中有一个粒子系统引擎,粒子本身只是没有函数的变量的结构.目前,通过直接访问其变量,从其父类(ParticleSystem)更新每个粒子(粒子).例如

particle.x += particle.vx;

然而,我正在讨论使用这样的getter和setter:

particle.setX( particle.getX()+particle.getVX() );

我的问题是:调用getter和setter是否有任何性能开销而不是直接数据访问？

毕竟,我确实有许多粒子需要更新......

我似乎无法找到在实际例子中使用什么镜头的任何解释.Hackage页面中的这一短段是我发现的最接近的段落:

该模块提供了访问和更新结构元素的便捷方式.它与Data.Accessors非常相似,但更通用,依赖性更低.我特别喜欢它如何干净地处理状态monad中的嵌套结构.

那么,它们用于什么？他们对其他方法有什么好处和坏处？他们为什么需要？

我试图找到如何实现call/cc.我发现的最好的是这个Haskell片段:

callCC f = Cont $ \k -> runCont (f (\a -> Cont $ \_ -> k a)) k

虽然这不是那么简单,我想由于Cont和runCont.我也找到了它的功能描述,尽管从未像实际代码那样清晰.

那么它是如何以最简单的形式实现的呢？我用Scheme和Haskell标记它,因为这是我喜欢的两种语言.

为什么static const成员不能在本地课程中存在的原因是什么？这似乎是一个相当愚蠢的限制.

例:

void foo() {
  struct bar {
    int baz() { return 0; }   // allowed
    static const int qux = 0; // not allowed?!?
  };
}

struct non_local_bar {
  int baz() { return 0; }   // allowed
  static const int qux = 0; // allowed
};

从标准报价(9.8.4):

本地类不应具有静态数据成员.

在Haskell维基上,我读到了这个:

fib =
    let fib' 0 = 0
        fib' 1 = 1
        fib' n = fib (n - 1) + fib (n - 2)
    in  (map fib' [0 ..] !!)

比这更有效:

 fib x =
    let fib' 0 = 0
        fib' 1 = 1
        fib' n = fib (n - 1) + fib (n - 2)
    in  map fib' [0 ..] !! x

因为,"在第二种情况下,fib'是(重新)为每个参数x定义的,因此它不能浮出来."

我不明白这意味着什么.

1. 什么"浮出来"是什么意思？它是如何优化的？
2. 为什么fib'要为每次调用重新定义fib？
3. 这是eta扩张吗？