如果被调用的函数pthread_create具有以下结构
try{
...code....
pthread_detach(pthread_self());
pthread_exit(NULL);
}catch(...){
std::cout<<"I am here"<<std::endl;
}
为什么省略号的异常处理程序在执行时被调用pthread_exit？(请注意std::exception,例如,不会抛出)
在Java中:
class Base {
public Base() { System.out.println("Base::Base()"); virt(); }
void virt() { System.out.println("Base::virt()"); }
}
class Derived extends Base {
public Derived() { System.out.println("Derived::Derived()"); virt(); }
void virt() { System.out.println("Derived::virt()"); }
}
public class Main {
public static void main(String[] args) {
new Derived();
}
}
这将输出
Base::Base()
Derived::virt()
Derived::Derived()
Derived::virt()
但是,在C++中,结果是不同的:
Base::Base()
Base::virt() // ? Not Derived::virt()
Derived::Derived()
Derived::virt()
(有关C++代码,请参阅http://www.parashift.com/c++-faq-lite/calling-virtuals-from-ctors.html)
什么导致Java和C++之间的这种差异？这是vtable初始化的时间吗？
编辑:我确实理解Java和C++机制.我想知道的是这个设计决定背后的见解.
请考虑以下示例代码:
class C
{
public:
int* x;
};
void f()
{
C* c = static_cast<C*>(malloc(sizeof(C)));
c->x = nullptr; // <-- here
}
如果由于任何原因我不得不忍受未初始化的内存(当然,如果可能的话,我会打电话new C()),我仍然可以调用放置构造函数.但是,如果我省略这一点,如上所述,并手动初始化每个成员变量,是否会导致未定义的行为？即绕过构造函数本身未定义的行为,或者用类外的一些等效代码替换调用它是否合法？
(通过另一个完全不同的问题遇到这个问题;要求好奇......)
B类覆盖了A类的纯虚函数"print()".C类继承了B类,并且具有"使用A :: print"语句.既然C类不是抽象类呢？
class A {
public :
virtual void print() =0;
};
class B:public A {
public:
void print();
};
void B :: print() {
cout << "\nClass B print ()";
}
class C : public B {
public:
using A::print;
};
void funca (A *a) {
// a->print(1);
}
void funcb (B *b) {
b->print();
}
void funcc (C *c) {
c->print();
}
int main() {
B b;
C c;
funca(&c);
funcb(&c);
funcc(&c);
return 0;
}
输出:
Class …我很困惑,为什么以下代码无法编译
int foo(const float* &a) {
return 0;
}
int main() {
float* a;
foo(a);
return 0;
}
编译器给出错误:
错误:从'float*'类型的表达式初始化'const float*&'类型的引用无效
但是当我尝试在foo中没有引用时传递,它编译正常.
我认为它应该表现出相同的行为,无论我是否通过引用.
谢谢,
考虑以下:
struct A { /* ... */ };
A foo() {
auto p = std::make_pair(A{}, 2);
// ... do something
return p.first;
}
auto a = foo();
会p.first被复制,移动还是RVO-ed？
clang ++，g ++和MSVC 在以下代码上存在分歧：
class A {
private:
enum class E { NO, YES };
class B {
private:
friend E f1() { return E::YES; }
// friend E f2();
};
};
// A::E f2() { return A::E::YES; }
int main() {}
clang ++接受如下所示的代码。g ++以及MSVC抱怨在f1该A::E不可访问。如果f2未注释函数，则所有三个编译器都会抱怨其A::E无法访问的定义。
是f1在事实上是否有效？
我发现的相关标准件有：
嵌套类是成员，因此具有与任何其他成员相同的访问权限。
尽管仅此一项并不意味着嵌套类的朋友拥有与嵌套类相同的权限。
对成员的访问受该成员所在的类影响。该命名类是在其中查找并找到成员名称的类。如果在类中命名成员，
m则可以在R点访问成员N
m作为N公共成员，或
m作为的成员N是私有成员，并且 …
在下面的代码片段中，auto将变量推导出为double，但是我想要float。
auto one = 3.5;
它是否始终double用于带小数点的文字？如何确定浮点数和两倍数？
这似乎表明该程序可能具有未定义的行为，至少因为我们不能保证键类型的严格弱排序：
#include <map>
int main()
{
int x = 0, y = 1;
bool arbitrary = false;
std::map<int*, bool> m{
{&x, arbitrary},
{&y, arbitrary}
};
}
更一般地说，我们可以说带有指针键的映射是一个危险的*命题吗？或者有什么特别的规则我们可以依靠？
* 从学术上讲，即；实际上，我不知道主流实现实际上会在比较任意指针时引发地狱。
考虑以下示例：
struct vector {
int size() const;
bool empty() const;
};
bool vector::empty() const
{
return size() == 0;
}
生成的汇编代码vector::empty（通过 clang，经过优化）：
push rax
call vector::size() const
test eax, eax
sete al
pop rcx
ret
为什么要分配堆栈空间？它根本没有被使用。该push和pop可以省略。MSVC 和 gcc 的优化构建也为此功能使用堆栈空间（请参阅有关Godbolt 的内容），因此必须有一个原因。