constructor and destructor

最新推荐文章于 2025-04-13 21:53:27 发布
原创 最新推荐文章于 2025-04-13 21:53:27 发布 · 563 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#destructor #constructor #object #inheritance #struct #class

本文详细解析了构造函数与析构函数的区别，包括完整对象构造函数、基对象构造函数、分配对象构造函数、完整对象析构函数、基对象析构函数和删除对象析构函数，并通过代码示例展示了它们在不同继承情况下的应用。同时，解释了构造函数和析构函数的不同时序和调用方式。

 <ctor-dtor-name> ::= C1   # complete object constructor
                 ::= C2   # base object constructor
                 ::= C3   # complete object allocating constructor
                 ::= D0   # deleting destructor
                 ::= D1   # complete object destructor
                 ::= D2   # base object destructor

 

•The "complete object constructor". It additionally constructs virtual base classes.
•The "base object constructor". It creates the object itself, as well as data members and non-virtual base classes.
•The "allocating object constructor". It does everything the complete object constructor does, plus it calls operator new to actually allocate the memory... but apparently this is not usually seen.
•D2 is the "base object destructor". It destroys the object itself, as well as data members and non-virtual base classes.
•D1 is the "complete object destructor". It additionally destroys virtual base classes.
•D0 is the "deleting object destructor". It does everything the complete object destructor does, plus it calls operator delete to actually free the memory.

 

There are usually two variants of the constructor (not-in-charge / in-charge) and three of the destructor (not-in-charge / in-charge / in-charge deleting).

The not-in-charge ctor and dtor are used when handling an object of a class that inherits from another class using the virtual keyword, when the object is not the complete object (so the current object is "not in charge" of constructing or destructing the virtual base object). This ctor receives a pointer to the virtual base object and stores it.

The in-charge ctor and dtors are for all the other cases, i.e. if there is no virtual inheritance involved; if the class has a virtual destructor, the in-charge deleting dtor pointer goes into the vtable slot, while a scope that knows the dynamic type of the object (i.e. for objects with automatic or static storage duration) will use the in-charge dtor (because this memory should not be freed).

Code example:

struct foo {     foo(int);     virtual ~foo(void);     int bar; };  struct baz : virtual foo {     baz(void);     virtual ~baz(void); };  struct quux : baz {     quux(void);     virtual ~quux(void); };  foo::foo(int i) { bar = i; } foo::~foo(void) { return; }  baz::baz(void) : foo(1) { return; } baz::~baz(void) { return; }  quux::quux(void) : foo(2), baz() { return; } quux::~quux(void) { return; }  baz b1; std::auto_ptr<foo> b2(new baz); quux q1; std::auto_ptr<foo> q2(new quux); Results:

•The dtor entry in each of the vtables for foo, baz and quux point at the respective in-charge deleting dtor.
•b1 and b2 are constructed by baz() in-charge, which calls foo(1) in-charge
•q1 and q2 are constructed by quux() in-charge, which falls foo(2) in-charge and baz() not-in-charge with a pointer to the foo object it constructed earlier
•q2 is destructed by ~auto_ptr() in-charge, which calls the virtual dtor ~quux() in-charge deleting, which calls ~baz() not-in-charge, ~foo() in-charge and operator delete.
•q1 is destructed by ~quux() in-charge, which calls ~baz() not-in-charge and ~foo() in-charge
•b2 is destructed by ~auto_ptr() in-charge, which calls the virtual dtor ~baz() in-charge deleting, which calls ~foo() in-charge and operator delete
•b1 is destructed by ~baz() in-charge, which calls ~foo() in-charge
Anyone deriving from quux would use its not-in-charge ctor and dtor and take on the responsibility of creating the foo object.

In principle, the not-in-charge variant is never needed for a class that has no virtual bases; in that case, the in-charge variant is then sometimes called unified, and/or the symbols for both in-charge and not-in-charge are aliased to a single implementation.

 

 

文章来源： http://stackoverflow.com/questions/6613870/gnu-gcc-g-why-does-it-generate-multiple-dtors/6614369#6614369

constructor和destructor概述（c++ only)
Magicpang
10-28 1万+
原文请参考http://publib.boulder.ibm.com/infocenter/lnxpcomp/v8v101/index.jsp?topic=/com.ibm.xlcpp8l.doc/language/ref/cplr374.htmconstructor和destructor概述（c++ only)对象的初始化和清除比简单的数据结构复杂的多，这是因为类有比较复杂的内部
Constructor(构造函数） and Destructor（析构函数）
qq_43186100的博客
09-24 645
构造函数 它是一种机制，他能保证我们的对象只要创建出来就可以被初始化。 构造函数没有返回类型，他在类对象被创建的时候自动被调用。 析构函数 析构函数：在类对象结束之前会被调用 ，他是不带参数的。 constructoranddestructoe.h #ifndef CONSTRUCTORANDDESTRUCTOR_H #define CONSTRUCTORANDDESTRUCTOR_H #include <QWidget> class ConstructorAndDestructor : p
c++：构造函数（Constructor）与析构函数（Destructor）
2402_88047672的博客
04-13 727
构造函数？构造函数是一种特殊的函数，在你创建对象的时候，自动调用，用来进行初始化。关键点：它和类同名。它没有返回值。它在对象创建的那一刻被调用（不是你手动调用，它自动来）。它的存在是为了：让对象一出生就是“有意义的、完整的”状态。// 构造函数name = n;age = a;// ← 自动调用构造函数你创建对象的时候，构造函数就被调用，把 name 和 age 初始化成你想要的值。析构函数是一个在对象“销毁”时自动调用的特殊函数。
【C++】类和对象--constructor和destructor
onlyongwang的博客
06-03 3629
Constructor：人称构造函数，用来初始化class，在class内部或外部都可以定义，在实例化class的时候会被调用。 Constructor的写法一般会有： 1. 默认的构造函数，也就是实例化的时候不带任何变量就能调用的构造函数；（这种情况有可能是构造函数就没给默认值，也可能是给了固定的默认值） 2. 重载构造函数，在有或者没有默认构造函数的基础上，带有相关变量，用来初始化cla...
C 语言中的constructor与destructor
滴水成川
09-20 6677
最近在看代码的时候碰到一个问题，这项目中有一个全局变量，里面有许多系统用的属性。但是一直找不到它在哪里被赋值。后来跟了代码才发现在系统开始之前已经有一个constructor将这个东西初始化好。     GCC可以给函数若干属性，其中construction就是其中一个。具体有哪些属性，可以看GCC的文档。http://gcc.gnu.org/onlinedocs/gcc/Function-At
#include <string> // program uses C++ standard string class using namespace std; // GradeBook class definition class GradeBook { public: // constructor initializes course name and instructor name GradeBook( string, string ); void setCourseName( string ); // function to set the course name string getCourseName(); // function to retrieve the course name string getInstructorName();//a get function for the instructor's name void setInstructorName(string);//a set function for the instructor's name void displayMessage(); // display welcome message and instructor name private: string courseName; // course name for this GradeBook string instructorName; // instructor name for this GradeBook }; // end class GradeBook 根据我提供的头文件修正错误
最新发布
10-17
要根据 `GradeBook` 类头文件修正“没有与参数列表匹配的构造函数 `GradeBook::GradeBook` 实例”错误，需要确保构造函数的参数类型与创建对象时传入的参数类型相匹配。以下是几种可能的情况及修正方法： ...
// Lab 2: GradeBook.cpp // Member-function definitions for class GradeBook. #include <iostream> using namespace std; // include definition of class GradeBook from GradeBook.h #include "GradeBook.h" // constructor initializes courseName and instructorName // with strings supplied as arguments GradeBook::GradeBook( string course, string instructor ) { setCourseName( course ); // initializes courseName setInstructorName( instructor ); // initialiZes instructorName } // end GradeBook constructor // function to set the course name void GradeBook::setCourseName( string name ) { courseName = name; // store the course name } // end function setCourseName // function to retrieve the course name string GradeBook::getCourseName() { return courseName; } // end function getCourseName /* write code to define a get member function for the instructor's name */ /* write code to define a set member function for the instructor's name */ // display a welcome message and the instructor's name void GradeBook::displayMessage() { // display a welcome message containing the course name cout << "Welcome to the grade book for\n" << getCourseName() << "!" << endl; /* write code to output the instructor's name */ } // end function displayMessage
10-17
// Display a welcome message and the instructor's name void GradeBook::displayMessage() { // Display a welcome message containing the course name cout () !" ; // Output the instructor's name cout ...
// Lab 2: GradeBook.cpp // Member-function definitions for class GradeBook. #include <iostream> using namespace std; // include definition of class GradeBook from GradeBook.h #include "GradeBook.h" // constructor initializes courseName and instructorName // with strings supplied as arguments GradeBook::GradeBook( string course, string instructor ) { setCourseName( course ); // initializes courseName setInstructorName( instructor ); // initialiZes instructorName } // end GradeBook constructor // function to set the course name void GradeBook::setCourseName( string name ) { courseName = name; // store the course name } // end function setCourseName // function to retrieve the course name string GradeBook::getCourseName() { return courseName; } // end function getCourseName /* write code to define a get member function for the instructor's name */ /* write code to define a set member function for the instructor's name */ string GradeBook::getInstructorName() { return instructorName; } // end function getInstructorName // function to set the instructor's name void GradeBook::setInstructorName( string name ) { instructorName = name; // store the instructor's name } // end function setInstructorName // display a welcome message and the instructor's name void GradeBook::displayMessage() { // display a welcome message containing the course name cout << "Welcome to the grade book for\n" << getCourseName() << "!" << endl; /* write code to output the instructor's name */ } // end function displayMessage 逐行分析代码
10-17
// constructor initializes courseName and instructorName GradeBook::GradeBook(string course, string instructor) { setCourseName(course); // 调用setter初始化courseName setInstructorName(instructor); ...
C++专题: constructor and destructor
foxbillcsdn的专栏
05-24 1490
1. 构造函数1.1. 缺省构造函数  缺省构造函数指不带任何参数的构造函数。1.1.1. 使用方法class CA{public:  CA() { mi = 0 ; }  int getMi(){ return mi ; }private:  int mi;};int main(){  CA oa;  CA* poa = new CA;  // 或者 new CA();   int i;
GDB查看C++对象布局
tmhanks的博客
04-11 5270
GDB查看C++对象布局 C++类包含数据成员（static，nonstatic）和成员函数（static、nonstatic、virtual）。 C++对象模型完成对数据成员和成员函数的构建。本文对以下模型的构建进行分析： 单一类 单继承无重写 单继承有重写 多继承 虚继承 菱形继承 单一类 class Base{ public: Base():m_base(0){} vir...
【C# 基础精讲】构造函数和析构函数
繁依Fanyi的博客
08-12 2756
构造函数和析构函数是面向对象编程中不可或缺的两个概念，分别用于在对象创建和销毁的时候执行特定的操作。构造函数用于初始化对象的状态，确保对象在创建后具有正确的属性值。析构函数用于释放资源、执行清理操作，以及确保对象销毁时的一些必要处理。在C#中，构造函数和析构函数在对象的生命周期中发挥着重要作用，通过合理地使用它们，可以提高代码的可维护性和安全性。在使用析构函数时，应当注意垃圾回收器会自动管理内存，而资源的释放应优先考虑使用using语句、Dispose()方法等资源管理技术，以确保代码的高效和稳定。
C++ class notes(二)
qq_64338302的博客
06-02 1266
这两个函数是最基本的成员函数。它们与对象的生成与销毁相关。constructor用于创造对象，destructor用于销毁对象。这两个成员函数没啥好说的，只是简单易懂的概念与语法。
C++构造函数（Constructor）、析构函数（Destructor）和拷贝构造函数（Copy Constructor）
ultramand的博客
02-09 740
使用引用作为参数可以避免额外的拷贝开销，提高性能，并且确保在拷贝构造函数中对对象进行的修改会反映在原始对象上。构造函数用于初始化对象的数据成员，析构函数用于在对象销毁之前执行清理操作，而拷贝构造函数用于创建一个新对象并将其初始化为已存在对象的副本。表示一个拷贝构造函数，使用了常量引用作为参数，以确保在拷贝过程中不会修改被拷贝对象的值，并通过引用访问和复制原始对象的数据，提高性能和保持一致性。修饰拷贝构造函数的参数可以确保在拷贝构造过程中不会修改被拷贝对象的值，保证了拷贝构造过程的安全性和一致性。
C函数特性：构造与析构（constructor & destructor）
EastWood2013的个人空间
09-07 496
是 GCC 编译器的一个扩展属性，它允许你定义一个特殊的函数，这个函数会在 main 函数执行结束后，或者当调用 exit() 函数退出程序时自动执行。当你使用这个属性时，GCC 编译器会确保这个函数在程序的构造阶段被调用，也就是在 C++ 中的 std::ios_base::Init 对象被销毁之前。是 GCC 编译器的一个特性，它允许定义一个特殊的函数，这个函数会在 main 函数执行之前，也就是程序开始执行时被调用。这个优先级是一个整数值，优先级较小的构造函数会先于优先级较大的构造函数执行。
__attribute__中的constructor和destructor
hw5230的博客
01-14 1751
其它可选的属性值还可以是：cleanup，common，nocommon，deprecated，mode，section，shared， tls_model，transparent_union，unused，vector_size，weak，dllimport，dlexport等。在使用__attribute__参数时，你也可以在参数的前后都加上“__”（两个下划线），例如，使用__aligned__而不是aligned，这样，你就可以在相应的头文件里使用它而不用关心头文件里是否有重名的宏定义。
C 语言中的constructor与destructor属性
dingdongkk~博客
08-26 2290
GCC可以给函数若干属性，其中constructor就是其中一个。具体有哪些属性，可以看GCC的文档。 公共属性：https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#Common-Function-Attributes 所有属性：http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html 在上面文档中有对于constructor与destructor的描述： ..
C++的constructor和destructor
清梦的博客
01-15 543
默认constructor的删除，构建自己的constructor，destructor调用
如何在C语言中使用constructor和destructor,gcc环境
善假于物
03-22 1132
使用这个功能，你就可以在main函数执行之前，和main函数退出之后，执行你自己想要的操作。 示例： #include #include static void start (void)  __attribute__ ((constructor)); static void stop  (void)  __attribute__ ((destructor));
constructor
08-23
<think>我们注意到用户输入中只有一个单词：constructor。这可能是用户想要了解JavaScript中构造函数的用法。 因此，我们将围绕JavaScript中的构造函数进行详细解释，包括ES5的函数构造函数和ES6的class语法中的constructor方法。 同时，我们会提供代码示例并解释。</think>### JavaScript 中的构造函数详解 在 JavaScript 中，`constructor` 是一个特殊的方法，用于创建和初始化类创建的对象。它扮演着以下关键角色： 1. **对象初始化**：在创建类实例时自动调用 2. **属性设置**：用于设置对象的初始状态 3. **继承基础**：在类继承中通过 `super()` 调用父类构造函数 #### 基础用法示例 ```javascript class Person { // 构造函数 constructor(name, age) { this.name = name; // 设置实例属性 this.age = age; console.log(`创建了 ${name} 实例`); } greet() { console.log(`你好，我是 ${this.name}，今年 ${this.age} 岁`); } } // 实例化 const alice = new Person("Alice", 30); alice.greet(); // 输出: // 创建了 Alice 实例 // 你好，我是 Alice，今年 30 岁 ``` #### 继承中的构造函数 ```javascript class Employee extends Person { constructor(name, age, position) { super(name, age); // 必须首先调用父类构造函数 this.position = position; } work() { console.log(`${this.name} 担任 ${this.position} 职位`); } } const bob = new Employee("Bob", 25, "工程师"); bob.greet(); // 继承自Person bob.work(); // 输出: // 创建了 Bob 实例 // 你好，我是 Bob，今年 25 岁 // Bob 担任 工程师 职位 ``` #### 关键规则： 1. **必须的 super()**：在继承类中，访问 `this` 前必须先调用 `super()` 2. **默认构造函数**：如果没有显式定义，JS 会添加默认的空构造函数 3. **返回值**：构造函数不应返回任何值（返回原始值会被忽略，返回对象会替代实例） #### 构造函数 vs 普通方法 | 特性 | 构造函数 | 普通方法 | |------|----------|----------| | 调用方式 | 通过 `new` 关键字 | 通过实例调用 | | 目的 | 初始化对象状态 | 定义对象行为 | | 返回值 | 应返回 `undefined` | 可返回任意值 | | 命名 | 固定为 `constructor` | 自定义名称 | #### 高级用法：私有字段（ES2022+） ```javascript class SecureAccount { #balance = 0; // 私有字段 constructor(initialBalance) { this.#balance = initialBalance; } deposit(amount) { if (amount > 0) this.#balance += amount; } get balance() { return this.#balance; } } const account = new SecureAccount(100); account.deposit(50); console.log(account.balance); // 150 // console.log(account.#balance); // 报错：私有字段不可访问 ``` #### 常见错误处理 ```javascript class Parent { constructor() { this.value = 10; } } class Child extends Parent { constructor() { // 错误：未调用 super() 前访问 this // this.childValue = 20; // ReferenceError super(); // 正确位置 this.childValue = 20; } } const child = new Child(); console.log(child.value, child.childValue); // 10, 20 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值