我问是否
Type t{...};
和
Type t({...});
和
Type t = {...};
相当于？如果一个工作,另一个也应该使用相同的结果？
如果没有explicit修饰语,它们是否相同？
要使类的函数成为一个槽,该类必须从QObject继承.但是,QObject占用了相当大的内存.我不确定它是多少以及内存是针对每个类还是每个对象.我的代码有许多小数据,其功能有时可以是一个插槽.我很想知道是否有一种方法可以在使用它时使类的功能成为时间槽.使用后,将删除插槽成本的内存.以下代码说明了该要求.
class SmallData // size of 2 or 3 integers.
{
public:
virtual void F(); // use it as a slot.
virtual QMenu* createMenu(); // use this to create the context menu with
// an action connected to F()
...
};
// use the small data
vector<SmallData> vec(1000000); // the vector is put at a tree view. When an
// item in the tree view is selected, a context
// menu pop up with an action to run F().
SmallData* …例如,我有一个像元组
std::tuple<T0, T1, T2> tp;
我可以按std::get()功能获得它的元素
auto e0 = std::get<0>(tp);
我更喜欢使用有意义的索引来访问除数字之外的元素.一种方法是定义类似的枚举
enum MyEnum
{
WHAT_T0_MEANS = 0,
WHAT_T1_MEANS = 1,
WHAT_T2_MEANS = 2
};
因此,我可以使用友好版本的喜欢
auto e0 = std::get<WHAT_T0_MEANS>(tp);
问题是,有时我发现元组中的类型顺序不友好,并将其更改为喜欢std::tuple<T1, T0, T2>.但是很容易忘记改变枚举中元素的顺序.一个好方法可能是定义T0在类T0中的含义,或者使用map来查找T0的含义,否则.然后编写一些函数来通过T0的含义来获取元素.有办法吗？这里,枚举元素不需要T0的含义.它可以是一种类型或其他任何东西.
如果T0,T1和T2是不同的类型.功能就像
T MyGet<T>(tp)
T可以是T0,T1或T2,没关系.
例如,我有一个元组
std::tuple<int, int, int, int> a(2, 3, 1, 4);
我想使用以下函数获取其元素的位置.
int GetPosition(const std::tuple<int, int, int, int>& tp, int element);
这里2的位置是0,3的位置是1,1的位置是3和4'position是3.如何实现这个功能？一种愚蠢的方式是
int GetPosition(const std::tuple<int, int, int, int>& tp, int element)
{
if (std::get<0>(tp) == element) return 0;
if (std::get<1>(tp) == element) return 1;
if (std::get<2>(tp) == element) return 2;
... // Write as more as an allowed max number of elements
}
有更好的方法吗？谢谢.
当我将光标悬停在 Visual Studio 2012 中代码中调用的函数上时，会弹出一个小框来显示其声明。如何让它为构造函数工作？
Function(1, 2); // Hover on Function
MyClass a(1, 2); // Hover on a or MyClass or use any shortcut key
假设我有一个较低级别的类层次结构
class A {...};
class A0 : public A {...};
class A1 : public A {...};
class A2 : public A {...};
我想用更高级别来表示它,比如带有图标的GUI级别,在这些类中添加虚拟方法可能很容易
virtual Icon A::icon() {return iconOfA;}
virtual Icon A0::icon() {return iconOfA0;}
virtual Icon A1::icon() {return iconOfA1;}
virtual Icon A2::icon() {return iconOfA2;}
但是,我不想改变低级别类,任何简单的方法来实现它？我希望动态地使用它,比如
A* a = new A2();
getIcon(a); // will return iconOfA2.
谢谢.
如果存在依赖关系,编译器是否可以正确处理静态变量的初始化顺序？例如,我有
a.h:
struct A { static double a; };
a.cpp:
#include "a.h"
double A::a = 1;
b.h:
struct B { static double b; };
b.cpp:
#include "b.h"
#include "a.h"
double B::b = A::a;
以下案例怎么样？如果存在依赖关系,编译器是否可以正确处理静态变量的初始化顺序？
啊
template<class T>
struct A { static double a; };
template<class T>
double A<T>::a = 1;
BH
struct B { static double b; };
b.cpp
#include "b.h"
#include "a.h"
double B::b = A<int>::a;
例如,我有一个功能
void A::fun()
{
do_1();
emit signal_1();
do_2();
emit signal_2();
do_3();
}
signal_1和之间有联系slot_1; 之间signal_2和slot_2.当在slot_1和slot_2叫什么名字？一些答案选项:
slot_1之前slot_2;slot_1之后调用do_1并被slot_2调用
do_2或其他人.
例如，我有一个元组
tuple<int, float, char> t(0, 1.1, 'c');
和模板功能
template<class T> void foo(T e);
并且我想用该函数循环元组元素，如何实现它，如使用boost :: mpl :: for_each实现以下内容？
template<class Tuple>
void loopFoo(Tuple t)
{
foo<std::tuple_element<0, Tuple>::type>(std::get<0>(t));
foo<std::tuple_element<1, Tuple>::type>(std::get<1>(t));
foo<std::tuple_element<2, Tuple>::type>(std::get<2>(t));
...
}