假设有两个具有自动存储持续时间的对象:
{
ClassA objA(...);
ClassB objB(...);
// [A] code that uses objA and objB.
// [B] objA is no longer used after this point.
// ... more code ...
} // [C] objA and objB go out of scope.
C++标准是否指定了objA和objB构造函数的相对顺序?例如,我们是否可以假设当调用objA的构造函数时,由objB的构造函数引起的任何副作用都是
我使用Borland C++生成器。
我有个问题
#include <Classes.hpp>
class TMyObject : public TObject
{
__fastcall TMyObject();
__fastcall ~TMyObject();//I would like to inherite my destructor from TObject
};
__fastcall TMyObject::TMyObject() : TObject()//it will inherited my constructor from TObject
{
}
对于
在D wiki - 上有一个关于C++接口的页面
它说,您可以链接到C++代码,但不能链接到特殊的方法,包括构造函数、析构函数和运算符重载,因为对象的生存期问题。建议要么使用包装器(并在C/C++端构造对象),要么用D重新实现构造函数。这两种方法都需要做大量工作,有时可能是不可能的。如果您想在您的D程序中使用一些C++库,这是一个很大的问题:例如,您希望使用Qt的QML,并且可以定义与extern(C++)...一起使用的所需的类,但是您仍然需要构造函数和许多包装器(比如dqml项目做的)或移植代码。
但有一种方式看起来很有效。简单的例子:
//class.h
class MyTestCla
我将键入一个示例:
class A
{
public:
virtual ~A(){}
};
class B: public A
{
public:
~B()
{
}
};
int main(void)
{
A * a = new B;
delete a;
return 0;
}
现在在上面的例子中,析构函数将从下到上递归调用。我的问题是Compiler是如何做到这一点的。
我是c++新手,我有两个关于如何调用基本构造函数的查询。
1.)让我们说我的代码看起来有点像这样。
#include<iostream>
using namespace std;
class Base {
public:
Base() { cout<<"Constructor: Base"<<endl; }
virtual ~Base() { cout<<"Destructor : Base"<<endl; }
};
class Derived: public Base
class base{
public:
~base(){
cout<<"base class delete"<<endl;
}
};
class derived:public base{
public:
~derived(){
cout<<"derived class 1 delete"<<endl;
}
};
class derived2:public base,publi
我试着理解在退出范围时析构函数调用的顺序。假设我有以下代码:
class Parent{
Parent(){cout<<"parent c called \n";}
~Parent(){cout<< "parent d called \n";}
};
class Child: public parent{
Child(){cout<< "child c called \n";}
~Child(){cout<<"child d called\n";}
};
现在,我知道子构造函数
如何在C++/CX中声明从Windows.Foundation.IClosable继承的运行时接口?
这两种尝试都会产生编译器错误:
public interface class MyInterface : Windows::Foundation::IClosable {
/* bla bla */
};
==> error C2039: 'IClosable' : is not a member of 'Windows::Foundation'
和
public interface class MyInterface {
/* bla bla
我读到析构函数不能共享,这是真的吗?
我有一个带有几个子类的基类,这些子类的析构函数不会改变。这将导致一些重复的代码。
可以共享析构函数吗?如果没有,我该如何避免这些析构函数中的重复代码呢?
Class A{
public:
~A() {
//do something
}
};
class B: public A{
};
class C: public A{
};
class D: public A{
};
现在,我希望B、C和D具有与A相同的析构函数。
在下面的代码中,b是基类指针。但是,当我调用析构函数(显式或隐式地通过delete)时,派生类析构函数首先被调用。我不明白这是怎么回事。可以有任意数量的派生类,每个派生类都有自己的析构函数。编译器如何知道从基析构函数调用哪个派生类析构函数?
#include <iostream>
using namespace std;
class Base {
public:
virtual ~Base() { cout << "Base destructor" << endl; }
};
class Derived : public Bas
但是在后台发生了什么呢?
我的意思是一个子类继承了它的基类的这个虚拟析构函数。继承某些东西对我来说意味着获得它的原样。但在这种情况下,子类不会获得基类所具有的析构函数。(也许它会变得一样,特别是如果它没有身体的话)。关键是,即使子类没有重新定义它,它也会做其他事情。那么这是如何工作的呢?
假设我们有(C++):
class BaseClass{
int i;
public:
virtual ~BaseClass(){}
};
class SubClass: public BaseClass{
int j;
};
BaseClass* bptr = new SubClass;
这个问题是基于Scott在他的书“更有效的C++”中提供的一个例子。请考虑以下课程:
// A class to represent the profile of a user in a dating site for animal lovers.
class AnimalLoverProfile
{
public:
AnimalLoverProfile(const string& name,
const string& profilePictureFileName = "",
在“加速C++”的第11章中,作者提出了一个用数组模拟std::向量行为的向量类。他们使用分配程序类来处理内存管理。uncreate函数的作用是销毁数组的每个元素并释放分配给数组的空间:
template <class T> void Vec<T>::uncreate() {
if (data) {
// destroy (in reverse order) the elements that were constructed
iterator it = avail;
while (it != data)
alloc.destroy(--it