小编Mic*_*ael的帖子

假设我有类似的东西:

template <class T>
void do_something(T t){
  pass_it_somewhere(t);
  t->do_something();
}

现在T允许是指针类型或非指针类型是有用的.函数do_something(...)基本上可以处理指针和非指针,除了t->do_something().对于指针,我需要一个->和非指针,我需要一个.访问成员.

有没有办法让T接受指针和非指针？

我必须比较两个更大的对象是否相等.

对象的属性:

1. 按值包含所有成员(因此没有指针可用).
2. 它们还包含一些stl::array.
3. 它们包含一些其他对象,其中1和2保持.
4. 大小高达几KB.
5. 其中一些members将比其他更有可能不同,因此如果首先进行比较,会导致比较操作更快地中断.
6. 对象不会改变.基本上,算法只是计算有多少对象是相同的.每个对象仅与几个"主"对象进行一次比较.

比较这些对象的最佳方法是什么？我看到三个选择:

1. 只需使用普通,非重载operator==.
2. ==从可能不同的成员开始,重载并执行逐个成员的比较.
3. 重载==并将对象视为普通字节字段并逐字比较.

一些想法:
选项1似乎很好,因为它意味着最少的工作量(以及引入错误的机会).
选项2似乎很好,因为我可以利用关于哪些元素最不可能的启发式.但也许它仍然较慢,因为==选项1的内置速度非常快.
选项3似乎是最"低级"优化的,但这也是编译器可能也对选项1做的.

所以问题是:

• 有没有一种众所周知的解决任务的最佳方法？
• 绝对禁止的选择之一是什么？
• 我还需要考虑别的吗？

我有一个模拟代码,我想在编译时进行一些配置:例如,我需要定义维度,数据类型和包含低级操作的类(内联的编译时).

就像是:

template <int DIMENSION, class DATATYPE, class OPERATIONS>
class Simulation{ ... }

template <int DIMENSION, class DATATYPE, class OPERATIONS>
class SimulationNode{ ... }

template <int DIMENSION, class DATATYPE, class OPERATIONS>
class SimulationDataBuffer{ ... }

首先,为每个类编写整个参数集非常烦人.其次,更糟糕的是,可能需要引入一个额外的参数,我必须更改所有类.

是否有像模板参数的结构？

就像是

struct {
  DIMENSION = 3;
  DATATYPE = int;
  OPERATIONS = SimpleOps;
} CONFIG;

template <class CONFIG>
class Simulation{ ... }

template <class CONFIG>
class SimulationNode{ ... }

template <class CONFIG>
class SimulationDataBuffer{ ... }

对于模板参数给出的类型,C++有一些鸭子类型.我们不知道什么类型DUCK1和DUCK2将来,但只要他们可以quack(),它将编译和运行:

template <class DUCK1, class DUCK2>
void let_them_quack(DUCK1* donald, DUCK2* daisy){
  donald->quack();
  daisy->quack();
}

但是写起来有点不方便.当我完全不关心什么实际类型DUCK1和DUCK2有,而是要充分利用鸭打字的想法,那么我想有一些sligthly不同于上面:

1. 我想省略编写一个重复且大多没有意义的模板参数列表(想象一下如果有7只鸭子会发生什么......)
2. 我想更清楚地说明这些类型从未使用过,而且它只是重要的接口.
3. 我想要一种界面注释/检查.以某种方式清楚该类型背后的接口.(然而,这与鸭子打字有点形成对比.)

C++是否提供任何功能来实现3个想法中的一个或多个？

(我知道虚拟继承在大多数情况下是实现这种模式的首选方法,但这里的问题是关于静态多态的情况.)

我有一个矩形网格.这些矩形中的每一个都由矩形网格点组成.矩形内的所有点都可以通过内核中完全相同的指令序列来处理.我将能够启动一个具有10000个点的内核来处理,其中每个线程将处理大约10-50个点.然而,矩形的边缘和角上的点将导致大量不同的指令序列.

从设计的角度来看,使用相同的指令序列为每组点启动内核会更容易.这意味着一些内核启动只会处理非常少的点,可能少于10.

所以我可能有4个内核启动,10000个点可以处理(每个线程10-50个点),也许30-100个内核启动,每个只有几个点(通常每个线程1个点).

我完全不知道这是否可以接受,或者它是否会完全破坏我的表现.我很高兴你能给我一个粗略的估计或至少一些提示,考虑什么来估计.

我很确定以下问题在其他地方已经有了一个很好的答案,但很难找到,因为我不知道我的问题的"名称".

我正在设计一个具有以下属性的类/对象/"东西":

• 它是一种查找表.
• 初始化后它不会改变.
• 它有几个非原始成员.
• 它具有复杂的初始化函数.
• 整个计划都是一样的.
• 它由模板参数参数化.

所以这听起来像一个静态模板类:

template <int T>
class LookupTable{

  public:
    static void init(){
      // create entries depending on T
    }

  private:
    static vector<Entries> entries;

}

我不喜欢的是我需要init()在我的程序中调用某个地方.所以第一个问题是:如何让这个类完全自包含,不需要在某个地方显式初始化？

第二部分:实现这样一个类的一般设计方法是什么？我很高兴看到一个很好的例子的链接.

一个可能的候选人是单身人士.但我有些疑惑: - 在许多情况下,单身人士认为设计不好.如上所述,查找表是否可以？ - Singleton有点长,因为我必须使用LookupTable::getInstance()->getEntry(idx).

问题出在以下问题的背景下:为什么找不到库,即使它们显然位于-L路径上？.我的库和我的目标文件似乎有不同的ELF格式,这可能导致链接器无法"找到"库.

现在,这导致了几个问题:

1. 看来我的编译器通常会生成SYSV ELF文件.(选中file).但是,对于该特定的C++源代码,它会生成Linux/GNU ELF目标文件.我想知道为什么,所以我将该源减少为一个空的main方法 - 然后我突然得到一个SYSV对象文件.C++源文件中的内容可以导致编译器切换ELF格式？

2. 我不能将Linux/GNU与SYSV ELF链接在一起是真是假？

3. 是否有强制编译器创建某种ELF格式的选项？

我正在使用Cray g ++(GCC)5.3.0 20151204.

我正在开发一个HTML5 Canvas和KineticJS的项目.半透明覆盖(KineticJS组或层)遍布整个场景.问题是:不处理绑定到此叠加层下的KineticJS对象的鼠标事件.

如何使这个叠加(或任何其他对象)对鼠标事件"透明"？

注意:问题只是关于Canvas,没有其他HTML元素干扰它.(以明确下面提到的内容.)

Eclipse（Luna，4.4.2）告诉我以下行有语法错误：

static_cast<Vec<int, DIM>>(a.mul(b));

我记得双右尖括号>>可能会导致某些编译器出现问题，所以我在中间添加了一个空格：> >。语法错误消失。

但是，>>我的程序中有很多没有检测到语法错误，例如：

Node<Element<DIM>> * e= a.get();

为什么我会在上述特定情况下收到错误？这与错误相关：“varName”未在此范围内声明，但我不知道为什么我的编译器>>有时会接受 a，但并非总是如此。

假设我有一个 nxm 矩阵并想fct对其每个元素调用一个函数。我可以这样做：

A = numpy.array(...)
vec_func = numpy.vectorize(fct)
A_out = vec_func(A)

这将严格地将函数应用于每个矩阵元素，fct 将是一个函数：

def fct(a_ij):
  # do something with matrix element a(i, j)

现在我想要同样的，但是对于矩阵的每一行：

def fct(row_i):
  # do something with matrix row(i)

有没有办法做到这一点numpy.vectorize或类似？