C++堆和栈的8大区别&&C++内存管理+namespace命名空间

已于 2022-05-18 12:28:32 修改
阅读量901 收藏 1
点赞数 5
分类专栏： C++基础练习 文章标签： c++ 开发语言
于 2022-05-18 11:59:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41694574/article/details/124839333
版权

堆和栈的8大区别——C++命名空间——内存管理

《引言》

古之欲明明德与天下者，先知其国。欲治其国者，先齐其家。欲齐其家者，先修其身。欲修其身者，先正其心。欲正其心者，先诚其意。欲诚其意者，先致其知。致知在格物。

在这里插入图片描述

文章目录

1·命名空间——namespace/using

1·1命名空间出现的目的

大型程序开发会使用多个独立开发的库，当汇聚到一起时，会出现全面的名字，类，函数和模板，名字冲突情况。多个库放在一起会引发 命名空间污染

**命名空间（namespace）**将命名空间分割了全局命名空间，其中每个命名空间时要给作用域。通过某个命名空间中定义库的名字，库的作者可以避免全局名字固有的限制

1·2命名空间的定义

关键字+名字

namespace HWK{
	int a;
    int b;
    int c;
}

只要能出现在全局作用域中的声明就可以置于命名空间内

命名空间作用域之后无须分号

1·3 ::作用域解析符来进行对应访问

HWK::a;

#include<iostream>
#include <vector>
using namespace std;
namespace HWK {
	int a;
	int b;
	int c;
}
int main() {
	cin >> HWK::a;
	cout << HWK::a;
	return 0;
}

1·4命名空间可以不连续

如果已经存在了与现在命名空间相同的一个空间，那么新的空间名字将会追加在其后面

#include<iostream>
#include <vector>
using namespace std;
namespace HWK {
	int a;
}
namespace HWK {
	int k;
}
int main() {
	cin >> HWK::k;
	cout << HWK::k;
	return 0;
}

1.5嵌套的命名空间

#include<iostream>
#include <vector>
using namespace std;
namespace HWK {
	int a;
	//嵌套命名空间
	namespace HWK {
		int k;
	}
}
int main() {
	//嵌套访问
	cin >> HWK::HWK::k;
	cout << HWK::HWK::k;
	return 0;
}

1.6未命名的命名空间

#include<iostream>
#include <vector>
using namespace std;
namespace {
	int n;
}
int main() {
	cin >> n;
	cout << n;
	return 0;
}

未命名的名字空间仅在特定的文件内部有效，其作用范围不会横跨多个不同文件

其空间中定义的变量拥有静态生命周期，它们在第一次使用前创建，并且直到程序结束之后才销毁，同时它与全局变量名不能够重复

1.7使用using将名字空间成员引入

#include <iostream>
using namespace  std;
namespace HWK{
    int n;
    int m;
    int HWK;
}
using HWK::m;//如果注释掉这一行，则报错出现错误，在这里引入的时候一定要注意，要加上作用域解析符
int main(){
    cin>>m;
    cout<<m;
    return 0;
}

1.8 使用using namespace 将名字空间引入

#include <iostream>
using namespace  std;
namespace HWK{
    int n;
    int m;
    int HWK;
}
//在这里引入空间，那么就可以直接使用了
using namespace HWK;
int main(){
    cin>>m;
    cout<<m;
    return 0;
}

2·C/C++中的内存管理

ORl8gK.png

2·1-C语言的动态内存管理

栈是由系统管理-在Windows其默认大小为1M,在Linux上的大小是10M

1M =1024K*1024K

在vs2019当中可以通过设置来修改栈的大小

2·1·1什么是动态内存

在内存的-堆区申请空间–完全由程序人员管理

2·1·2动态内存管理函数

程序运行的过程中申请一定大小的内存，使用完成之后，还给操作系统

空间申请完了，一定要进行释放

释放完了之后一定要置为空

2·1·3动态内存管理的四个函数：malloc,calloc,realloc,free

需要引入stdlib.h或malloc.h函数

2·1·3·1malloc与calloc的区别
  1. 内存申请了之后一定要进行判空👌👌👌
  2. malloc申请的堆区内存初始化为随机值
  3. calloc申请的堆区内存初始化为0
#include <stdlib.h>
#include <iostream>
using namespace  std;
//c的动态内存管理
int main(){
    int n=10;
    int *ipa=(int *) malloc(sizeof(int)*n);//初始化为随机值
    int *ipb=(int *) calloc(n, sizeof(int));//初始化为0;
   // ipa=(int *) realloc(ipa, sizeof(int)*n*2);
    free(ipa);
    ipa= NULL;
    free(ipb);
    ipb=NULL;
    return 0;
}

ORUmD0.png

ORNTHK.png

2·1·3·2自己通过malloc实现calloc函数
#include <stdlib.h>
#include <iostream>
#include <cstring>

using namespace  std;
//size_t类型表示C中任何对象所能达到的最大长度，是无符号整型
void * My_calloc(::size_t num,size_t size){
    void *vp= malloc(num*size);
    if(vp!=NULL){
        memset(vp,0,num*size);
    }
    return vp;
}
//c的动态内存管理
int main(){
    int n=10;
    int *ipa=(int *) malloc(sizeof(int)*n);//初始化为随机值
    if(ipa==NULL){
        exit(1);
    }
    int *ipb=(int *) My_calloc(n, sizeof(int));//初始化为0;
   	if(ipb==NULL){
        exit(1);
    }
   // ipa=(int *) realloc(ipa, sizeof(int)*n*2);
    free(ipa);
    ipa= NULL;
    free(ipb);
    ipb=NULL;
    return 0;
}

//callloc 的两个参数
int* ip = (int*)calloc(10, sizeof(int));
2·1·3·3 malloc申请内存的的底层申请与越界

free()释放必须全部释放-不能释放一半

ORgszV.png

#include <stdlib.h>
#include <iostream>
#include <cstring>
int main(){
    int n=10;
    int *p=(int *) malloc(sizeof(int)*n);//申请40个字节空间的大小
    free(p);//必须全部释放
}

ORh9hj.png

int main() {
	int n = 10;
	int* p = (int*)malloc(sizeof(int) * n);//申请40个字节空间的大小
	//当i<=n的时候将会覆盖下越界标记，在释放时将会报错
	for (int i = 0; i <= n; i++) {
		p[i] = i;
	}
	free(p);//必须全部释放
}

ORh25Q.png

ORhTbT.png

2·3·1·4 内存泄漏的两种情况
  1. 一直在堆区申请内存空间，但从来没有进行释放
  2. malloc申请了内存空间的地址，丢失了其地址,找不到申请空间的开始地址

程序结束（进程结束之后）操作系统自动回收

2·1·3·5 free()使用的注意事项

free(ipa):是将其指向的空间还给系统（将标记修改为0），同时进行对应的填充dd，以防后面的程序可以读取当中的内容，加强安全性

⚠️⚠️⚠️free()之后指针一定一定置为NULL

⚠️⚠️⚠️free()之后指针一定一定置为NULL

⚠️⚠️⚠️free()之后指针一定一定置为NULL

对于同一个空间，不能够释放两次，如果释放两次则将报错

2·1·3·6 realloc()

我们通过下面代码，申请了大小位20个字节的空间，那么realloc()是怎么回事呢？

#include <iostream>
#include<stdlib.h>
#include<malloc.h>
using namespace std;
int main() {
	int n = 5;
	int* ip = (int*)malloc(sizeof(int) * n);
	if (ip == nullptr) {
		exit(1);
	}
	for (int i = 0; i < n; i++) {
		ip[i] = i;
	}
	int m = 10;
	return 0;
}

OIkCcD.png

realloc()是在ip的后面继续追加对应的内存，那在这里我们追加ip两倍的内存

#include <iostream>
#include<stdlib.h>
#include<malloc.h>
using namespace std;
int main() {
	int n = 5;
	int* ip = (int*)malloc(sizeof(int) * n);
	if (ip == nullptr) {
		exit(1);
	}
	for (int i = 0; i < n; i++) {
		ip[i] = i;
	}
	int m = 10;
	ip = (int*)realloc(ip,sizeof(int)*2);
	free(ip);
    ip=nullptr;

	return 0;
}

我们来看下实验结果：

OIAXJx.png

在这里我们注意其内存地址，现在是 0X0127CA60

我们再来看下当我们追加之后ip的地址和大小

通过下面的代码，我们可以看到，刚刚好10个大小，并且内存还是地址没有变-

OIELng.png

2.1.3.6realloc内存追加的两种情况
  1. 上图这种比较顺利的情况，在第一次申请的后面刚好有 有需要大小的空间，加起来刚好够
  2. 后面的部分不够了，那么realloc()就会重新找一块儿内存，并搬移过去之前的数据

2.2 C++ 中的new和delete

运算符new分配内存，delete释放new分配的内存

2.2.1运算符new–分配内存空间

自由的空间是无名的，因此new无法为其分配的对象命名，所以返回的是一个指向该对象的指针

2.2.1.1⭐动态内存分配的对象最好进行初始化
//此 new在堆空间构造一个int类型的对象，并返回该对象的指针
int *pi=new int;//pi指向一个动态分配的、未初始化的无名对象
string *ps=new string;//ps指向一个动态分配的，未初始化的无名对象


#include<iostream>
#include<vector>
using namespace std;
int main() {
	//初始化的几种方式
	int* pi = new int(1024);//pi指向的对象为1024
	string* ps = new string(10, 9);//*ps为"9999999999"
	//vector有10个元素一次从0到9
	vector<int>* pv = new vector<int>{ 0,1,2,3,4,5,6,7,8,9 };
	
	string* ps1 = new string;//默认初始化为空
	string* ps2 = new string();//值初始化为空
	int *pi1 = new int;//默认初始化；*pil的值未定义
	int* pi2 = new int();//值初始化为0；*pi2的值为0
    delete(pi);
    delete(ps);
    delete(pv);
    delete(ps1);
    delete(ps2);
    delete(pi1);
    delete(pi2);

	return 0;
}

OINkA1.png

2.1.1.2通过auto来初始化new的类型–不过要注意，只有单一初始化时才可以使用auto
#include<iostream>
#include<vector>
using namespace std;
int main() {
	int obj = 0;//在这里auto推导时，一定要有初始值
	auto p1 = new auto(obj);
	int a = 0, b = 0, c = 0;
	auto p2 = new auto(a, b, c);//error --编译器不通过
	return 0;
}
//p1的类型是一个指针，指向从obj自动推断出的类型。若obj是一个整形，则它为整型，如果为string ,则它为string * 新分配的对象用 obj初始化  比如 Obj为 10 那么*p1=10;

OIdQHJ.png

2.1.2.3动态分配const对象

动态分配的const对象必须进行初始化。对于一个定义了默认构造函数的类 类型，其const动态对象可以隐式初始化，而其他类型的对象必须显示初始化。

分配的对象是const所以返回的指针也是一个指向const类型的指针

#include<iostream>
#include<vector>
using namespace std;
int main() {
	const int* pi = new const int;
	const string* ps = new const string;
	return 0;

}

OI0g0g.png

2.2.2通过函数形式使用new–与malloc类似

#include<iostream>
#include<vector>
using namespace std;
int main() {

	int n = 10;
	int* ip = (int*)::operator new(sizeof(int) * 10);
	int* ip1 = (int*)::operator new(sizeof(int));
	delete (ip);
	return 0;
}

2.3.3定位new

如果内存被耗尽，new申请内存失败，则会抛出一个类型为bad_alloc的异常–我们称之为定位new

如果不想抛出 异常要求返回一个空指针可以使用 nothrow来将其返回值 修改成空指针

#include<iostream>
#include<vector>
#include<new>
using namespace std;
//定位new
int main() {

	int* p1 = new int;//如果分配失败，new抛出 std::bad_alloc
	int* p2 = new(nothrow)int;//如果分配失败，new 返回一个空指针
	delete p1;
	p1 = nullptr;
	delete p2;
	p2 = nullptr;
	return 0;
}

2.3.4.4 对于内置类型 new / delete / malloc/free 可以混用

#include<iostream>
#include<vector>
#include<new>
using namespace std;
//定位new
int main() {

	int* p1 = new int(1024);
	int *p2=(int *)malloc(sizeof(int)*10);
	free (p1);
	p1 = nullptr;
	delete p2;
	p2 = nullptr;
	return 0;
}

两点注释事项

	p2 = nullptr;
	delete p2;//可以释放是个空指针
	int i;
	delete i;//error 不能够释放一个不是指针的对象

3.⭐⭐⭐栈和堆的8大区别

区别栈堆
管理方式操作系统自动管理程序员控制，使用方便，容易产生内存泄漏
生长方式向下分配-由高地址,向低地址扩展,连续的内存区域向上分配-由低地址向高地址扩展-不连续的内存区域
空间大小由系统预先预定(默认1M或10M)受限于计算机系统的有效虚拟内存,32位Linux可达2.9G
存储内容栈在函数调用时,先压入函数实参,然后主调函数中下条指定地址入栈,最后时被调函数的局部变量.调用结束后,局部变量先出栈,指令地址出战,最后栈平衡通常在头部用要一个字节存放其大小,堆用于存储生存期与函数调用无关的数据,具体由程序员自己安排
分配方式栈可静态分配或动态分配.静态分配由编译器完成,如局部变量的分配.动态分配由alloca函数在栈上申请空间,用完后不用调用free释放只能动态分配并且手动释放
分配效率底层提供支持,分配专门的寄存器存放栈地址,压栈出栈由专门指令执行,因此效率高由函数库提供,机制复杂效率低
分配后系统响应只要栈剩余空间大于所申请空间,系统将为程序提供内存,否则报告异常提示栈溢出操作系统提供记录一个空闲内存地址的链表
碎片问题不存在碎片问题,因为栈是先进后出,内存块弹出栈之前,上面后进栈内容已经弹出频繁申请释放会造成内存空间不连续,从而造成大量碎片,使其使用效率降低
HANWEN KE
关注
专栏目录
C++的内存模型以及命名空间(namespace)
qq_40755025的博客
05-06 363
1.静态成员变量的内存分配 如果一个类中有静态成员(static)，注意，不能在类的声明中初始化静态成员，这是因为声明只是描述了如何分配内存，而并没有分配内存，所以，对于静态成员的初始化，需要在类的声明之外进行 所以，静态成员在类的声明中声明，在包含类方法的文件中初始化 ，初始化时应使用作用域运算符来指出静态成员所属的类 2.分配内存与释放内存 在构造函数中使用new来分配内存时，必...
C++类和命名空间的使用
qq_57780685的博客
09-02 1083
命名空间、类的使用
C++ 命名空间、异常处理和动态内存
qq_28576837的博客
08-02 986
命名空间 异常处理 动态内存
【C++ 语言】命名空间 ( namespace | 命名空间定义 | 命名空间嵌套 | 域作用符 | 与 include 对比 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-13 1556
命名空间简介 自定义命名空间 自定义嵌套命名空间 域作用符 命名空间 与 include 区别 命名空间定义与使用完整代码
C++命名空间超级大详解
qq_39545674的博客
12-29 446
文章目录1 什么是命名空间？2 为什么要有命名空间3 命名空间里有些什么4 怎样创建一个命名空间1. 创建方法2. **头文件和cpp文件**3.命名空间的定义可以不连续4. 命名空间可以嵌套定义5. 未命名的命名空间5 怎样使用命名空间1. 通过命名空间名使用2. 通过using方法使用3. 别名4. 注意事项 1 什么是命名空间？   本质上，命名空间就是一个范围标识，比如大家都在中国，有中...
C++学习笔记二（内存空间、指针、命名空间、编译步骤）
weixin_45885074的博客
09-09 1011
C++learning notes
【C++研发面试笔记】3. 命名空间与内存管理
tostq的专栏
10-01 2100
【C++研发面试笔记】3. 命名空间与内存管理3.1 命名空间命名空间就是将多个变量和函数等包含在内，使其不会与命名空间外的任何变量和函数等发生重命名的冲突。 在其中的很多实例中，都有这么一条语句：using namespace std;，即使用命名空间std，其作用就是规定该文件中使用的标准库函数都是在标准命名空间std中定义的。 3.1.1 使用命名空间解决名字冲突修改两个头文件，把在头文件
C++内存管理（2）new、delete详解
qq_25218501的博客
09-07 1266
在C++中，内存管理是开发者的一项重要责任，也是容易出错的地方。开发者可能会遗忘释放已分配的内存，导致内存泄漏。重载new和delete可以帮助开发者更好地追踪和管理内存分配。通过在重载的new和delete操作符中插入日志或者调试语句，开发者可以监测和记录所有内存分配和释放的情况，从而检测内存泄漏。
C++ 内存管理简明教程
neweastsun的专栏
04-10 1502
C++ 在运行时给变量或数组分配内存，也称为动态内存分配。其他语言(如Java, Python)由编译器控制内存，但C++需要手动维护，当不需要时也要手动回收动态创建的内存。本文介绍C++动态内容管理，并通过示例进行说明。 内存管理目的 数组包括相同类型数据，大多数情况下声明数组时，内存已经分配。如果分配太小，可能不够使用，反之可能造成浪费。那么最好的办法使用new操作符在运行时动态分配。 new操作符 下面示例使用new操作符给指针变量分配内存. // 声明 int 指针 int* pointerVa.
【C++/嵌入式梳理】一、12.C++内存管理
Hi
05-21 474
一、12.C++内存管理
C/C++内存分配管理
热门推荐
一只大笨猫的博客
08-13 1万+
内存分配及管理 1.内存分配方式 在C++中内存分为5个区，分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。 堆：堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。 栈：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于...
4万字c++讲解+区分c和c++，不来可惜了（含代码+解析）
阿玥的小博客
02-22 1万+
变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。多个变量赋同一个值时，需要分别赋值。//错误x = y = z;extern 数据类型 变量名;数据类型 变量名1,变量名2,...变量名n;// 变量声明// 变量定义int a, b;// 初始化a = 23;b = 25;return 0;函数类型-函数的返回值类型。
【内存模型和名称空间】——C++ Prime Plus CH9
m0_58378145的博客
10-13 360
学习记录
C语言中union的用法
zyqash的博客
09-21 269
在C语言中，union（联合体）是一种特殊的复合数据类型，它允许多个不同的数据成员共享同一块内存空间。与struct（结构体）不同的是，union中的所有成员共用同一个内存地址，因此同时只能存储一个成员的值。
C++ STL中sort函数
weixin_43349440的博客
09-15 431
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
pyqt瀑布流布局
最新发布
weixin_54217201的博客
09-21 295
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
标准C++（二）
m0_63127040的博客
09-18 806
在C语言中定义的全局变量、函数、结构、联合、枚举、枚举值、宏都在全局作用域下，所以当项目比较庞大时，非常容易造成命名冲突（以模块名作前缀、后缀），所以C++中选择把全局作用域进行拆分成子作用域进行管理，这些子作用域就是作名字空间。把抽象结果（利用面向对象的思维模式，思考、观察出的结果），使用用C++的语法封装出一种类似结构的自定义数据类型（复合数据类型）。使用设计好的类（结构）这种数据类型，定义出的类变量在面向对象编程语言中被称为对象（结构变量），创建类对象的行为也被称为实例化对象。int id;
C++_map_set详解
2302_77644537的博客
09-16 1059
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C++与Java编程语言对比：特性、复杂性与内存管理
C++是栈式和堆式内存管理的结合，程序员需要手动分配和释放内存，如果处理不当可能导致内存泄漏或悬挂指针等问题。Java则采用垃圾回收机制，自动管理内存，避免了这些问题，但这也可能导致性能开销。 3. **面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HANWEN KE

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值