相关疑难解决方法(0)

如果我有这个代码:

class A { ... };
class B { ... };

void dummy()
{
    A a(...);
    B b(...);
    ...
}

我知道,变量a和b将在反向分配顺序(被破坏b将首先被破坏,则a); 但我可以肯定的是,优化器将永不掉的分配和建设a和b？或者我必须volatile用来执行它？

我希望为类的堆栈分配实例调用一个特殊的构造函数/析构函数，并且：

1. 禁止所有其他情况（我认为这是不可能的）。

或者

2. 让他们调用不同的构造函数/析构函数。

这可以移植吗？

我为什么要这样做？
我正在编写一个容器类库，其中包含一个潜在的大型动态分配缓冲区。
从概念上讲，它应该像这样工作：

class SArray(){
    size_t size;
    char* data;
    SArray(size_t _size):size(_size){
        data = (char*)malloc(size);
    }

    ~SArray(){
        free(data);
    }
... Some operators, etc. ...
}

然而，这对我所在领域（高性能机器人）的用户来说是一个重大的放缓。当您从系统分配时，大分配首先映射到零页，当您写入它们时会导致页面错误，然后 - 出于安全原因 - 内核在将数据提供给您之前花费大量时间将数据清零。我的用户倾向于分配许多小缓冲区（sub-KB）和非常大的缓冲区（1-1000 MB）。

如果我们可以确定以 LIFO(stack) 顺序调用构造函数和析构函数，那么我们就可以拥有一个巨大的虚拟堆栈来进行内存分配：

class SArray(){
    static char backing_stack[1000000000000]; // 1TB, at least as big as all of RAM
    static sp = 0;
    size_t size;
    char* data;
    SArray(size_t _size):size(_size){
        data = backing_stack + sp;
        sp += size;
    }

    ~SArray(){
        sp -= size;
    }
... Some operators, …

我编写了以下类来测试多级继承概念.当我试图测试对构造函数和析构函数的调用时,有一点我真的不明白.

#include <iostream>

using namespace std;

class X{

    public:
        X(){cout <<"Construct X " << endl;};
        virtual ~X(){cout <<"Destruct X " << endl;};
        virtual void print() const = 0;
};

class Y: public X{
    public:
        Y(){cout <<"construct Y " << endl;};
        ~Y(){cout <<"Destruct Y " << endl;};
        void print() const{
            cout <<"print Y" << endl;
        };
};

class Z: public Y{
    public:
        Z(){cout <<"Construct Z" << endl; };
        ~Z(){cout <<"Destruct Z " << endl; };
        void print() const{
            cout <<" Print …

据我所知，调用析构函数的顺序与创建对象的顺序相反。

然而，在下面的代码中，我不明白为什么 C(1) 和 C(2) 的析构函数在其构造函数之后立即被调用。

另外，语句 C(2) 和 C c3(3) 之间有什么区别。第二个是一个用值 3 初始化的对象。C(2) 的解释是什么？

#include <iostream>

class C {
public:
  C(int i)
  {   j = i;
      std::cout << "constructor called for "<<j << std::endl;;
    }
  ~C()
  { std::cout << "destructor called for "<<j<< std::endl;; }

private:
  int j;
};

int main() {
  C(1);
  C(2);

  C c3(3);
  C c4(4);
}

代码的输出是：

constructor called for 1
destructor called for 1
constructor called for 2
destructor called for 2
constructor called for …