首页 / C++ / C++中栈和堆上建立对象的区别

C++中栈和堆上建立对象的区别

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++中栈和堆上建立对象的区别，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8302字，纯文字阅读大概需要12分钟。

内容图文

在C++中类的对象建立分为两种，一种是静态建立，如A a；另一种是动态建立，如A* p=new A()，A*p=(A*)malloc()；静态建立一个类对象，是由编译器为对象在栈空间中分配内存，通过直接移动栈顶指针挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。动态建立类对象，是使用new运算符将对象建立在堆空间中，在栈中只保留了指向该对象的指针。栈是由编译器自动分配释放，存放函数的参数值，局部变量的值，对象的引用地址等。其操作方式类似于数据结构中的栈，通常都是被调用时处于存储空间中，调用完毕立即释放。堆中通常保存程序运行时动态创建的对象，C++堆中存放的对象需要由程序员分配释放，它存在程序运行的整个生命期，直到程序结束由OS释放。而在java中通常类的对象都分配在堆中，对象的回收由虚拟机的GC垃圾回收机制决定。

1.下面的程序来看看静态建立和动态建立对象的区别

             1 #include<iostream>
 2 #include<string>
 3usingnamespace std;
 4class  student
 5{
 6public:
 7string name;
 8int age;
 9void sayhello();
10};
11void student::sayhello()
12{
13     cout<<"my name is: "+this->name+" I am: "<<this->age;
14     cout<<"\n";
15}
16 student setname(string name)
17{
18    student stu;
19     stu.age=12;
20     stu.name=name;
21return stu;
22}
23int main()
24{
25     student stu=setname("jim");
26    stu.sayhello();
27return0;
28 }

程序运行结果：my name is: jim I am: 12;

程序定义了一个student类，在setname函数中定义一个局部对象作为返回值。程序第18行静态构建了一个student对象stu，它在栈上分配空间，在函数调用结束后就销毁了，函数返回的类对应在内存中的值应该不存在啊？其实原来C++在用类作为函数的返回值时调用了类的拷贝构造函数，而且该拷贝构造函数是在堆上分配存储空间，后面再讨论这个问题。

在setname函数内的stu在函数调用结束后就销毁了，可以添加一个析构函数来证明：

在student类中加入析构函数：

student::~student()
{
    cout<<this->name<<":gameover"<<endl;
}

程序运行结果：

技术分享

在sayhello()前，输出jim:gameover，即为setname()里的stu对象执行了析构函数。

如将setname函数改为：

student* setname(string name)
{
    student stu;
    stu.age=12;
    stu.name=name;
    return &stu;
}

main函数的调用改为：

            int
             main()
{
    student* p=setname("tom");
    p->sayhello();
    return0;
}

显然这里会出现问题，对象指针返回的是栈上的对象，在函数调用结束后已经销毁了，对象指针即为野指针，故程序在编译时会提示：warning C4172: returning address of local variable or temporary。解决这个问题我们自然想到把该对象构建在堆上即可。修改setname函数为下：

 student* setname(string name)
 {
student* stu= new student();
stu->age=12;
stu->name=name;
return  stu;
 }

main函数的调用不变；程序正常运行输出：
技术分享

上面输出结果并没有调用析构函数，在setname调用后，在main函数结束后也没有调用。在对上的对象需要程序员自己delete释放，将main改为如下：

            int
             main()
{
    student* p=setname("tom");
    p->sayhello();
    delete p;
    return0;
}

即加入delete p;运行结果：
技术分享

C中用malloc函数来动态申请空间，该内存分配在堆上。这里可以验证，加入#include <malloc.h>，将setname函数改为如下：

            1  student* setname(string name)
2 {
3 student* stu=(student*)malloc(sizeof(student));
4 stu->age=12;
5 stu->name=name;
6return  stu;
7  }

为在student中加入构造函数：

            student::student()
{
    cout<<"constructor"<<endl;
}

上面的程序执行到第5行会出错，原因是没有调用构造函数，stu->name根本就没有被初始化（string的构造函数没有被调用），所以不能赋值。具体的解释是：因为malloc只是分配堆内存（不会调用构造函数）它并不知道内存里要存的是什么。为此用new即可，将第3行代码改为：student* stu=new student;程序运行结果为下：

技术分享

即程序调用了构造函数。若非要用malloc来申请内存可以将setname函数改为如下：

            1  student* setname(string name)
2 {
3 student* stu=(student*)malloc(sizeof(student));
4new(stu) student;
5 stu->age=12;
6 stu->name=name;
7return  stu;
8  }

即加入了第4行程序正常运行，调用了构造函数。第4行大概可以理解为new了一个student对象，赋值转换为student的指针stu。
既然这样可以把第3行直接改为：student* stu；即

            1  student* setname(string name)
2 {
3//student*stu= new student;4 student* stu;
5new(stu) student;
6 stu->age=12;
7 stu->name=name;
8return  stu;
9  }

让说第4,5行的效果应该和第3行相同，编译程序提示：warning C4700: local variable ‘stu‘ used without having been initialized，即stu没有初始化。 new(stu) student;和stu= new student;并不等价。第5行并不是初始化，这里可以看做第5行这种写法（之前还真没见过）是C++为兼容malloc内存申请的用法，一般情况下推荐肯定是用new关键字。
到此其实这里要说明的主题已经基本说明了，关于malloc的用法当申请的类的成员变量只包含基本的数据类型（数值型int，double等）（string等引用类除外）时是不会出错的。下面的列子可以证明；

             1 #include<iostream>
 2 #include<string>
 3 #include <malloc.h>
 4usingnamespace std;
 5class course
 6{
 7public:
 8int id;
 9float score;
10void printscore()
11    {
12     cout<<"id:"<<this->id;
13         cout<<" score:"<<this->score<<endl;
14    }
15};
1617  course* setscore(int id,float score)
18 {
19      course* co= (course*)malloc(sizeof(course));
20      co->id=id;
21      co->score=score;
22return co;
23 }
24int main()
25{
26 course* cou=setscore(999,188.9);
27 cou->printscore();
28return0;
29 }

程序运行结果如下：

技术分享

程序第19行这样的用法没有问题，而之前的string类却有问题。这样看来，自定义类型作为类的成员时也应该会有问题，来看下面的代码：

             1 #include<iostream>
 2 #include<string>
 3 #include <malloc.h>
 4usingnamespace std;
 5class course;
 6class  student
 7{
 8public:
 9string  name;
10int age;
11        course cou;
12void sayhello();
13     ~student();
14    student();
15};
16student::student()
17{
18     cout<<"constructor"<<endl;
19}
20 student::~student()
21{
22     cout<<this->name<<":gameover"<<endl;
23}
24void student::sayhello()
25{
26     cout<<"my name is: "+this->name+" I am: "<<this->age;
27     cout<<"\n";
28}
29class course
30{
31public:
32int id;
33float score;
34void printscore()
35    {
36     cout<<"id:"<<this->id;
37         cout<<" score:"<<this->score<<endl;
38    }
39};
40  course* setscore(int id,float score)
41 {
42      course* co= (course*)malloc(sizeof(course));
43      co->id=id;
44      co->score=score;
45return co;
46 }
47  student* setname_score(string name ,course* cou)
48 {
49 student* stu= (student*)malloc(sizeof(student));
50 stu->age=12;
51new(stu)student;
52 stu->cou.id=cou->id;
53 stu->cou.score=cou->score;
54 stu->name= name;
55return  stu;
56 }
57int main()
58{
59 course* cou=setscore(999,188.9);
60 student* stu=setname_score("jimm",cou);
61 stu->cou.printscore();
62 stu->sayhello();
63return0;
64 }

这段代码中把course类对象作为student的类成员。程序编译出错： error C2079: ‘cou‘ uses undefined class ‘course‘。把course类的定义放在前面则没有错即：

                 1 #include<iostream>
 2 #include<string>
 3 #include <malloc.h>
 4usingnamespace std;
 5class course
 6{
 7public:
 8int id;
 9float score;
10void printscore()
11    {
12     cout<<"id:"<<this->id;
13         cout<<" score:"<<this->score<<endl;
14    }
15};
16class  student
17{
18public:
19string  name;
20int age;
21        course cou;
22void sayhello();
23     ~student();
24    student();
25};
26student::student()
27{
28     cout<<"constructor"<<endl;
29}
30 student::~student()
31{
32     cout<<this->name<<":gameover"<<endl;
33}
34void student::sayhello()
35{
36     cout<<"my name is: "+this->name+" I am: "<<this->age;
37     cout<<"\n";
38}
39 course* setscore(int id,float score)
40 {
41      course* co= (course*)malloc(sizeof(course));
42      co->id=id;
43      co->score=score;
44return co;
45 }
46 student* setname_score(string name ,course* cou)
47 {
48 student* stu= (student*)malloc(sizeof(student));
49 stu->age=12;
50new(stu)student;
51 stu->cou.id=cou->id;
52 stu->cou.score=cou->score;
53 stu->name= name;
54return  stu;
55 }
56int main()
57{
58 course* cou=setscore(999,188.9);
59 student* stu=setname_score("jimm",cou);
60 stu->cou.printscore();
61 stu->sayhello();
62return0;
63 }

View Code

运行结果为：

技术分享

上面程序setname_score函数中若不用new(stu)student;这种写法，则会出现未初始化的错误。这里完全可以将类的成员改为指针的形式，在初始化时用new在堆上分配存储。改写的代码如下：

                 1 #include<iostream>
 2 #include<string>
 3 #include <malloc.h>
 4usingnamespace std;
 5class course;
 6class  student
 7{
 8public:
 9string*  name;
10int age;
11         course* cou;
12void sayhello();
13     ~student();
14    student();
15};
16student::student()
17{
18     cout<<"constructor"<<endl;
19}
20 student::~student()
21{
22     cout<<this->name<<":gameover"<<endl;
23}
24void student::sayhello()
25{
26     cout<<"my name is: "+*(this->name)+" I am: "<<this->age;
27     cout<<"\n";
28}
29class course
30{
31public:
32int id;
33float score;
34void printscore()
35    {
36     cout<<"id:"<<this->id;
37         cout<<" score:"<<this->score<<endl;
38    }
39};
40 course* setscore(int id,float score)
41{
42      course* co= (course*)malloc(sizeof(course));
43      co->id=id;
44      co->score=score;
45return co;
46}
47 student* setname_score(string name ,course* cou)
48{
49 student* stu= (student*)malloc(sizeof(student));//student*stu=new student;也一样，只是一个调用构造函数，一个不调用50 stu->age=12;
51 stu->cou=new course();//这里用new建立对象52 stu->cou->id=cou->id;
53 stu->cou->score=cou->score;
54 stu->name=newstring(name);//new55return  stu;
56 }
57int main()
58{
59 course* cou=setscore(999,188.9);
60 student* stu=setname_score("jimm",cou);
61 stu->cou->printscore();
62 stu->sayhello();
63return0;
6465 }

View Code

上面程序运行结果为：
技术分享

综上所述，C++中对象的建立可以在堆和栈上。分别为动态建立和动态建立的方式，构建堆上的对象时一般使用new关键字，而将对象的指针在栈上。使用new在堆上构建的对象需要主动的delete销毁。C++对象可以在堆或栈中，函数的传参可以是对象(对象的拷贝)，或是对象的指针。而在java中对象一般分配在堆上，对象的传值只有值类型，即对象的引用（地址），这样看来C++要灵活的多。关于c++数组的内存分配还要这里提到的拷贝构造函数，下次再讨论啊。上面的程序在VC++6.0编写通过。

原文：http://www.cnblogs.com/xiaoxiaoqiang001/p/5557704.html

内容总结

以上是互联网集市为您收集整理的C++中栈和堆上建立对象的区别全部内容，希望文章能够帮你解决C++中栈和堆上建立对象的区别所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1333044.html

来源：【匿名】

【上一篇】数据结构c++版本【下一篇】c++有个库什么的吗?

更多 ►

【C++中栈和堆上建立对象的区别】教程文章相关的互联网学习教程文章

C++中栈和堆上建立对象的区别【代码】【图】

《C++ Primer》读书笔记之第15章：面向对象编程

一、面向对象概述1. 面向对象的三个基本特性：封装、继承和多态。2. 封装指把隐藏对象的实现细节，仅对外提供接口，从而达到接口与实现分离的效果。封装的好处：一是提高数据的安全性，用户只能使用对象提供的接口，而不能随意修改对象的数据。试想如果用户能够获取权限访问对象的所有实现细节并进行修改，那对象的安全性将无法保证。这和用外壳把电路板封装起来，以免用户随便拆卸电子器件的道理是类似的。二是方便使用。用户只需...

【总结】关于C++虚函数、多态和对象切割【代码】

貌似很少有把这几件事连在一起讲的，在网上查了好久，也翻了半天书才弄明白整个过程是怎么回事。先说现象再说原理： 1// vtableTest.cpp : Defines the entry point for the console application.2//3 4 #include "stdafx.h" 5 #include "iostream" 6usingnamespace std;7 8class Base9{ 10public: 11virtualvoid function1() {cout << "Base f1" << endl;}; 12virtualvoid function2() {cout << "Base f2" << endl;}; 13}; 1415...

学习BoolanC++笔记_04(C++面向对象高级编程（下）第五周)【图】

作者： ayaoko出处： http://www.cnblogs.com/fyc006/>关于作者：小可才疏学浅还请多多赐教！本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出, 原文链接如有问题，可邮件（270469391@qq.com）咨询./**/对象模型：关于vptr和vtbl、关于this、关于Dynamic Binding动态绑定：指针虚函数向上转型。A* pa=new B;pa->vfunc1();多态vfunc1: 扩展虚指针和虚函数表作者：ayaoko...

Linux Debugging: 使用GDB来理解C++ 对象的内存布局（多重继承，虚继承）【图】

前一段时间再次拜读《Inside the C++ Object Model》深入探索C++对象模型，有了进一步的理解，因此我也写了四篇博文算是读书笔记：Program Transformation Semantics （程序转换语义学）The Semantics of Copy Constructors(拷贝构造函数之编译背后的行为）The Semantics of Constructors: The Default Constructor （默认构造函数什么时候会被创建出来）The Semantics of Data: Data语义学深入探索C++对象模型这些文章都获...

【转】c++中使用memset初始化类对象【代码】

https://blog.csdn.net/u010261063/article/details/70064090 1 #include <iostream>2 #include <memory.h>3usingnamespace std;4 5class parent{6public:7virtualvoid output();8virtualvoid output2();9}; 1011void parent::output(){ 12 cout << "parent output" << endl; 13} 1415void parent::output2(){ 16 cout << "parent output2" << endl; 17} 1819class son : public parent{ 20public: 21void output(); 22}; ...

C++对象生命周期（未完）【代码】【图】

1.栈中生成的对象，其作用域为其在的{}中。遇到右括号}后执行析构函数。2.堆中生成的对象，即new生成的动态对象，需要delete执行析构函数。<pre name="code" class="cpp">#include<iostream> #include<string> #include<cstdio> using namespace std; class WithCC { public:int id;WithCC(int i):id(i) {printf("执行id为 %d 的WithCC构造函数！\n",id);}~WithCC() {printf("执行id为 %d 的WithCC析构函数！\n",id);} }; WithCC w...

[c++面试准备]--vector对象是如何增长的【代码】

参考资料：cpp primer 5th背景：为了支持快速的访问，vector/string将元素连续存储--每个元素都是紧挨着前一个元素存储。如果我们向vector/string中添加新的元素，会发生什么：由于连续存放的缘故，当没有多余的空间来容纳新的元素的时候，容器必须分配新的空间来保存已有的元素和新元素，将已有元素从旧位置移动到新空间中，然后添加新的元素，释放旧的空间。 vector不会对新添加的每一个元素都做上述操作，效率太慢。所以vector会...

C++ 类工厂实现动态对象创建【代码】

看了MFC中的动态创建对象后，感觉动态创建对象算是一种技术吧，理论上说算是一种设计模式。其实创建的原理很明了，把对象的类别名称和其构造函数用容器记录下来，在需要的时候给出创建类别查找容器即可创建对象。当然这里我们需要自定义一个全局的函数指针用来指向类别的构造函数。在这里我们使用类工厂模式，在泪工厂中我们定义一个通用构造函数，将函数指针指向它。下面是参考一位网友思路来整理和摸索的代码：//通用的函数指针 ...

C++ 无符号类型的运算对象参与的类型转换

我的主力博客：半亩方塘当某个运算符的运算对象类型不一致，且其中某一个运算对象是无符号类型时，这个需要进行相应地类型转换，至于类型转换的结果，则依赖于机器中各个整数类型的相对大小。当某个运算符的运算对象类型不一致，且其中某一个运算对象是无符号类型时，分为以下几种情况：当无符号类型的运算对象大于有符号类型的运算对象时，则将有符号类型转换为相应的无符号类型后再进行运算，转换规则见我的博客 C++ 中...

0713-----C++Primer听课笔记----------类和对象【代码】

1.要求：将一篇文章录入，然后实现查询:a)查询可以输入字符或者字符串b)将包含它们的单词输出c)允许重复d)如果输入查询有空格，当多个处理Ex：输入ro，应该打印出“microsift”输入”he wr”，则查询两次1.1 不用类实现#include <iostream> #include <string> #include <vector> #include <fstream> #include <stdexcept>usingnamespace std; /**第一个版本录入一篇文章查找字符串**/ ifstream &open_file(ifstream &is, cons...

C++ 类和对象基本认识和创建【代码】

? 对象赋值语句：对象1 = 对象2 注意的地方：对象的类型必须相同。两个对象之间的赋值，只是数据成员的赋值，而不对成员函数赋值。不同对象的成员函数占有不同的存储空间，而不同对象的成员函数是占用同一个函数代码段，无法对它们赋值。当类中有 ++ 指针 ++ 时，需要进行深拷贝。构造函数：构造函数是一种特殊的成员函数，它主要用于为对象分配空间，进行初始化。建立对象的两种形式：形式1：类名对象[(实参表)] 例如： Date d...

Effective C++：条款12：复制对象时勿忘其每一个成分

（一）一个继承体系的声明：class Date {...}; class Customer { public:... private:string name;Date lastTransaction; };class PriorityCustomer : public Customer { public:PriorityCustomer(const PriorityCustomer& rhs);PriorityCustomer& operator=(const PriorityCustomer& rhs); private:int priority; };任何时候只要我们承担起“为derived class撰写copying函数”的重责大任，必须很小心的也复制其base class成分。但...

转载：C++中两个类中互相包含对方对象的指针问题【代码】【图】

原文链接：http://www.cnblogs.com/hanxi/archive/2012/07/25/2608068.html　　前几天很不爽，因为C++中两个类中互相包含对方对象的指针编译时提示某一个类未定义。。。所以我就想啊想，这样也对，我的头文件都有#ifndef的，包含了一次就不能再包含了，以为就实现不了这样的功能，于是就改了设计方案：class A { public:A(B* pB):m_pB(pB){}private:B* m_pB; };class B { public:B() {} private:int m_i; };只在一个类中包含另一个...

c++实验3类和对象【代码】【图】

实验 3:part 1：验证 part 2：graph#include <iostream> #include "graph.h"usingnamespace std;int main() {Graph graph1(‘*‘,5);graph1.draw();system("pause");system("cls");Graph graph2(‘$‘,7);graph2.draw();system("pause");return0; } main.cpp// 类graph的实现 #include "graph.h" #include <iostream> usingnamespace std;// 带参数的构造函数的实现 Graph::Graph(char ch, int n): symbol(ch), size(n) { }//...

C++ - 技术教程分类

C++ 教程 C++ 简介 C++ 基本语法 C++ 注释 C++ 数据类型 C++ 变量类型 C++ 变量作用域 C++ 常量 C++ 修饰符类型 C++ 存储类 C++ 运算符 C++ 循环 C++ 判断 C++ 函数 C++ 数字 C++ 数组 C++ 字符串 C++ 指针 C++ 引用 C++ 日期 & 时间 C++ 基本的输入输出 C++ 数据结构 C++ 类 & 对象 C++ 继承 C++ 重载运算符和重载函数 C++ 多态 C++ 数据抽象 C++ 数据封装 C++ 接口（抽象类） C++ 文件和流 C++ 异常处理 C++ 动态内存 C++ 命名空间 C++ 模板 C++ 预处理器 C++ 信号处理 C++ 多线程 C++ Web 编程 C++ 标准库 C++ 有用的资源 C++ 实例 c++ 全部

C++ - 最热教程

C++通过共享内存实现进程间通信（windo...C++基于EasyX制作贪吃蛇游戏（一）文档 C++中的分治算法及常见题目汇总【C++】stringstream的str() 和 string...c++中内置函数qsort（快速排序）和bsea...VS2019 C++创建一个简单项目demo [C++]VS2015用动态链接(MD/MDd)方式编译...C/C++编程学习 - 第15周 ⑥ 药房管理万维考试系统检测不到VC++ 6.0环境解决...C/C++ QT自定义对话框与MID窗体

首页 / C++ / C++中栈和堆上建立对象的区别

C++中栈和堆上建立对象的区别

内容导读

内容图文

内容总结

内容备注

内容手机端

【C++中栈和堆上建立对象的区别】教程文章相关的互联网学习教程文章

C++中栈和堆上建立对象的区别【代码】【图】

《C++ Primer》读书笔记之第15章：面向对象编程

【总结】关于C++虚函数、多态和对象切割【代码】

学习BoolanC++笔记_04(C++面向对象高级编程（下）第五周)【图】

Linux Debugging: 使用GDB来理解C++ 对象的内存布局（多重继承，虚继承）【图】

【转】c++中使用memset初始化类对象【代码】

C++对象生命周期（未完）【代码】【图】

[c++面试准备]--vector对象是如何增长的【代码】

C++ 类工厂实现动态对象创建【代码】

C++ 无符号类型的运算对象参与的类型转换

0713-----C++Primer听课笔记----------类和对象【代码】

C++ 类和对象基本认识和创建【代码】

Effective C++：条款12：复制对象时勿忘其每一个成分

转载：C++中两个类中互相包含对方对象的指针问题【代码】【图】

c++实验3类和对象【代码】【图】

对象 - 相关标签

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程