小编Din*_*rya的帖子

如果我有一个类定义的类

class A {
protected:
    ~A(){ }
};

然后我可以动态分配个人以及像这样的对象数组

A* ptr1 = new A;
A* ptr2 = new A[10];

但是,当我为这个类定义构造函数时

class A {
public:
    A(){}
protected:
    ~A(){ }
};

然后我可以创建单个对象

A* ptr = new A;

但是当我尝试动态分配对象数组时

A* ptr = new A[10];

编译器(gcc-5.1和Visual Studio 2015)开始抱怨A :: ~A()是不可访问的.

谁能解释一下: -

1-为什么定义和未定义构造函数的行为差异.

2-定义构造函数时,为什么允许创建单个对象而不是对象数组.

想象一下这段代码:

class Base {
 public:
  virtual void foo(){}
};

class Derived: public Base {
  public:
    int i;
    void foo() override {}
    void do_derived() {
      std::cout << i;
    }
};

int main(){
  Base *ptr = new Base;
  Derived * static_ptr = static_cast<Derived*>(ptr);
  static_ptr->i = 10;  // Why does this work?
  static_ptr->foo(); // Why does this work?
  return 0;
}

为什么我在控制台上获得结果10？我想知道因为我认为ptr是指向基础对象的指针.因此,该对象不包含int i或方法do_derived().是否自动生成了一个新的derived-Object？

当我do_derived()在Base类中声明一个虚方法时,会选择这个,但为什么呢？

有时获取任何git存储库(通过执行" git fetch repository_URL")可能需要数小时,具体取决于存储库的大小和网络速度.

如果出于某种原因,用户取消了中途获取,然后尝试获取相同的存储库,在他/她取消最后一次获取的完全相同的环境中,获取将如何工作？

它会从中断处继续取回吗？

对于只有两个可能的代码执行分支的情况，在 c++20 中使用[[likely]]和属性的一般准则是什么？[[unlikely]]是否建议仅将[[likely]]or[[unlikely]]放在执行路径的一个分支上，或者我们应该将其中之一放在一个代码分支上，将另一个放在其余分支上。例如，我们应该做

if (condition) [[likely]]
{
}
else [[unlikely]]
{
}

或者

if (condition) [[likely]]
{
}
else
{
}

当我们知道 if 条件中的分支更有可能被执行时。

我们可以定义递归lambda函数

std::function<void(int)> fun = [&fun](int a) {  if (a) fun(a - 1); };

然后我们可以用它来调用它

fun(10);

但是,如果我将定义更改为

std::function<void(int)> fun = [fun](int a) {  if (a) fun(a - 1); };

然后尝试用它来打电话

fun(10);

发生分段错误.

有人可以解释为什么通过引用捕获工作而按值捕获会给出分段错误.

任何人都可以解释不允许位字段作为类的静态成员的原因吗？例如,一个类定义如下:

class A{
public:
    A() {}
    ~A(){}
private:
    static int mem :10;
};
int A::mem;

不编译.

使用不同的编译器编译此类: -

1- g ++抛出错误: -

错误:静态成员'mem'不能是位字段

static int mem :10;

错误:'int A :: mem'不是'class A'的静态数据成员

int A :: mem;

2-铛抛出错误: -

错误:静态成员'mem'不能是位字段

static int mem :10;

3-Visual Studio 15抛出错误: -

'A :: mem'::非法存储类

'int A :: mem':不允许成员函数重新声明

我们需要在关闭所有类型的编译器优化时使用volatile限定符,假设在启用编译器优化时需要它.

我阅读了有关SO Volatile和编译器优化的帖子,该文章说是,但没有给出任何需要它的特定用例.

有人可以指出仍然需要使用它们的情况,无论启用或禁用任何类型的优化.

当自定义比较对象始终返回相同的结果（可能是真或假但始终相同），同时将元素放在标准库容器中时，例如std::set或std::map. 例如

struct A{
   int i_mem;
   double d_mem;
};

bool operator > (const A& first, const A& second)
{
    //This is hard coded just for the sake of example and actual code could still return always return the same value due to bug in the logic.

    return false;
}

然后创建对象，如

set<A, greater<A>> mset{{5,434.5},{1,32.4},{3,29.3}};

在这种情况下，(5,434.5)当使用 g++-10 测试时，该集合只有第一个元素。