template <int N>
class myarray {
typedef int Bitmap;
public:
static Bitmap data[N];
};
template <int N> myarray<N>::Bitmap myarray<N>::data[N];
错误:'myarray'之前的预期构造函数,析构函数或类型转换
(这是关于未定义行为(UB)的另一个问题.如果这个代码在某些编译器上"起作用",那么在UB的土地上就没有任何意义.这是可以理解的.但正好在下面的哪一行我们会进入UB？)
(关于SO已经有很多非常相似的问题了,例如(1) 但是我很好奇在取消引用它们之前可以用指针安全地完成什么.)
从一个非常简单的Base类开始.没virtual办法.没有继承.(也许这可以扩展到任何POD？)
struct Base {
int first;
double second;
};
然后是一个简单的扩展,添加(非virtual)方法,不添加任何成员.没有virtual继承.
struct Derived : public Base {
int foo() { return first; }
int bar() { return second; }
};
然后,考虑以下几行.如果与定义的行为有一些偏差,我很想知道确切地知道哪些行.我的猜测是我们可以安全地对指针执行大部分计算.是否有可能这些指针计算中的一些,如果没有完全定义,至少会给我们某种"不确定/未指定/实现定义"的值,这些值并非完全没用？
void foo () {
Base b;
void * vp = &b; // (1) Defined behaviour?
cout << vp << endl; // (2) I hope this isn't a 'trap value'
cout << &b << endl; // (3a) Prints the same as …假设您想要按值从向量中删除单个元素.remove -erase有什么区别:
vector<int> v;
// add some values
vector<int>::iterator it = remove(v.begin(), v.end(), 5);
v.erase(it);
并找到 - 擦除
vector<int> v;
// add some values
vector<int>::iterator it = find(v.begin(), v.end(), 5);
if(it != v.end())
{
v.erase(it);
}
#include <iostream>
#include <vector>
class A
{
public:
A() { std::cout << "constructor" << std::endl; }
~A() { std::cout << "destructor" << std::endl; }
};
int main()
{
std::vector<A> myvec;
myvec.push_back(A());
myvec.push_back(A());
myvec.clear();
return 0;
}
输出:
constructor
destructor
constructor
destructor
destructor
destructor
destructor
这里有五个对析构函数的调用.前两个是由于临时传递给push_back.还有其他三个电话,但我预计会有两个额外的电话.
myvec.clear()将只清除两个内容,因此析构函数A应该只调用两次(而不是三次).为什么有一个额外的时间析构函数被调用？
但是,如果我只将一个元素推送到向量而不是两个,那么输出就像我预期的那样.
在R控制台,我预计print(x)它将始终提供相同的输出x.我一直认为print控制台使用它来实际打印所有内容.但是这里有一个额外的NULL print:
library(data.table)
print(data.table(1)[0])
# Empty data.table (0 rows) of 1 col: V1
# NULL # why is this 'NULL' printed here?
data.table(1)[0]
# Empty data.table (0 rows) of 1 col: V1
# .. but no 'NULL' here?
这个示例数据是由data.table包创建的,但我认为一般问题即使在不使用时仍然适用data.table:在控制台上使用什么函数/方法来打印返回值？
# R --vanilla # R version 3.2.3
我有一个基类和派生自它的类.基类Controllable充当输入循环的接口,并且从其派生的其他类在该循环中获取点以获取诸如按下键之类的事件.
class Controllable{
public:
virtual void setActive(bool state) { m_active = state; }
virtual void input(Event & e) =0;
private:
bool m_active;
};
class Button : public Controllable{
public:
void setActive(bool state){ /*do extra work*/ m_active = state; }
void input(Event & e) override;
};
由于Button该类处理来自事件队列的事件,因此将其设置为非活动状态(将其从输入循环中取出)可能会导致它丢失重要事件(如未按下的键),因此需要额外的代码才能将其置于友好的非活动状态国家应该在以后再次活跃起来.
我的问题是,确保setActive始终具有切换m_active到正确状态的预期效果的最佳方法是什么,同时,除非需要附加额外需要的代码,否则不需要派生类来定义它？
我无法解决这个问题.我已经找到所有简单从源顶点开始路径小号含有简单有向图的周期.即,不允许重复,当然除了循环连接回路径的单个重复顶点.
我知道如何使用DFS访问来查找图表是否有周期,但我找不到一种方法来使用它来查找从s开始的所有这些路径.
例如,在此图中
+->B-+
| v
s-->T-->A<---C
| ^
+->D-+
从那里开始s,将正确找到路径STABCA.但是找不到路径STADCA,因为顶点C被标记为DFS访问.
有人能暗示我如何解决这个问题吗？谢谢
我正在尝试对concurrent_vector类型进行排序,其中hits_object:
struct hits_object{
unsigned long int hash;
int position;
};
这是我正在使用的代码:
concurrent_vector<hits_object*> hits;
for(i=0;...){
hits_object *obj=(hits_object*)malloc(sizeof(hits_object));
obj->position=i;
obj->hash=_prevHash[tid];
hits[i]=obj;
}
现在我已经填满了一个concurrent_vector<hits_object*>电话hits.
但我想在position属性上对这个concurrent_vector进行排序!
以下是典型命中对象内部的示例:
0 1106579628979812621
4237 1978650773053442200
512 3993899825106178560
4749 739461489314544830
1024 1629056397321528633
5261 593672691728388007
1536 5320457688954994196
5773 9017584181485751685
2048 4321435111178287982
6285 7119721556722067586
2560 7464213275487369093
6797 5363778283295017380
3072 255404511111217936
7309 5944699400741478979
3584 1069999863423687408
7821 3050974832468442286
4096 5230358938835592022
8333 5235649807131532071
我想根据第一列(类型的"位置" int)对此进行排序.第二列是类型的"哈希" unsigned long int.
现在我尝试做以下事情:
std::sort(hits.begin(),hits.end(),compareByPosition);
其中compareByPosition定义为:
int compareByPosition(const void …有时我们喜欢通过引用获取一个大参数,并且如果可能的话也使参考const宣称它是一个输入参数.但是通过制作引用const,编译器然后允许自己转换数据,如果它是错误的类型.这意味着它不那么有效,但更令人担心的是我认为我指的是原始数据; 也许我会接受它的地址,而不是意识到我实际上是在接受一个临时的地址.
bar此代码中的调用失败.这是可取的,因为引用的类型不正确.调用bar_const也是错误的类型,但它默默地编译.这对我来说是不受欢迎的.
#include<vector>
using namespace std;
int vi;
void foo(int &) { }
void bar(long &) { }
void bar_const(const long &) { }
int main() {
foo(vi);
// bar(vi); // compiler error, as expected/desired
bar_const(vi);
}
传递轻量级只读引用最安全的方法是什么？我很想创建一个类似于参考的新模板.
(显然,int并且long是非常小的类型.但是我已经遇到了可以相互转换的更大的结构.当我采用const引用时,我不希望这种情况无声地发生.有时,将构造函数标记为明确的帮助,但这并不理想)
更新:我想象一个如下系统:想象一下有两个函数X byVal();和X& byRef();下面的代码块:
X x;
const_lvalue_ref<X> a = x; // I want this to compile
const_lvalue_ref<X> b = byVal(); // I want this to fail at compile time …如果特定表达式格式不正确,则很容易使用SFINAE来隐藏特定的函数重载.但我想反其道而行之,隐藏过载,当且仅当一个表达式是良好的,并在一个非常普遍的方式这样做.我有一个在clang 3.5.0和gcc 5.2.0中工作的解决方案,但我对任何评论和替代方案感兴趣.
理想情况下,会有一个内置constexpr bool函数/宏在编译时告诉我们特定表达式是否形成良好.
IS_WELL_FORMED( declval<T>() < declval<T>() ) // I want this as bool
可用于enable_if启用或禁用重载.
我找到了一个解决方案,但是我在g ++ 5.2.0和clang 3.5.0中遇到了一些奇怪的行为,我想知道是否有错误.
首先,我到目前为止找到的最强大的解决方案,适用于两个编译器.例如,我想测试是否T有.length()方法.这需要将表达式"隐藏"在另一个模板中.此外,well_formed_default我将在稍后讨论一个函数.
// Define a template to contain our expression
template<typename T2=T, typename =
decltype( declval<T2>().length() ) // This line is the expression to test
> struct test_for_length_method { };
以下是它在包含类中的使用方式:
template<typename T>
struct Demo { // the main struct I'm working on
// Define a template …