内存管理下+模板初阶+STL简介

lisanndesu

已于 2024-04-30 13:09:04 修改

阅读量306

点赞数 10

分类专栏： C/C++内存管理文章标签：开发语言 c++

于 2024-04-21 17:35:24 首次发布

本文链接：https://blog.csdn.net/li_peixiansang/article/details/138039402

版权

C/C++内存管理专栏收录该内容

2 篇文章 0 订阅

订阅专栏

内存管理

new / delete 原理

new和delete底层都是malloc和free，只不过加上异常抛出等优化

关于C/C++ 申请/释放空间方式与细节

内置类型可以交错使用

自定义类型new/free不会调用析构函数

new多个obj时，会在首地址前多申请int字节储存申请obj个数

用于delete[]识别析构次数， delete不能识别析构次数，只能析构一次

对已有空间，如何显式调用构造

不可指针显式调用构造

可指针显示调用析构

new/delete多个对象及传参

用途：池化技术

内存池：提高效率

new时默认直接找堆，

想从内存池申请空间时，就要用到上述对已有对象空间的初始化

Mallc new freee delete区别

malloc，free是函数

new，delete是操作符

变量所在区域练习题

1. 选择题：

  选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)

  globalVar在哪里？____  staticGlobalVar在哪里？____

  staticVar在哪里？____  localVar在哪里？____

  num1 在哪里？____

  

  char2在哪里？____   *char2在哪里？___

  pChar3在哪里？____   *pChar3在哪里？____

  ptr1在哪里？____    *ptr1在哪里？____



2. 填空题：

  sizeof(num1) = ____;  

  sizeof(char2) = ____;   strlen(char2) = ____;

  sizeof(pChar3) = ____;   strlen(pChar3) = ____;

  sizeof(ptr1) = ____;

答案：

int globalVar = 1;

static int staticGlobalVar = 1;

void Test()

{

static int staticVar = 1;

int localVar = 1;



int num1[10] = {1, 2, 3, 4};

char char2[] = "abcd";

char* pChar3 = "abcd";

int* ptr1 = (int*)malloc(sizeof (int)*4);

int* ptr2 = (int*)calloc(4, sizeof(int));

int* ptr3 = (int*)realloc(ptr2, sizeof(int)*4);

free (ptr1);

free (ptr3);

}



1. 选择题：

  选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)

  globalVar在哪里？__C__  staticGlobalVar在哪里？__C__

  staticVar在哪里？__C__  localVar在哪里？__A__

  num1 在哪里？__A__

  分析:

  globalVar全局变量在数据段 staticGlobalVar静态全局变量在静态区

  staticVar静态局部变量在静态区  localVar局部变量在栈区

  num1局部变量在栈区

  

  char2在哪里？__A__  *char2在哪里？__A__

  pChar3在哪里？__A__   *pChar3在哪里？__D__

  ptr1在哪里？__A__    *ptr1在哪里？__B__

  分析:

  char2局部变量在栈区  

char2是一个数组，把后面常量串拷贝过来到数组中，数组在栈上，所以*char2在栈上



  pChar3局部变量在栈区   *pChar3得到的是字符串常量字符在代码段

  ptr1局部变量在栈区     *ptr1得到的是动态申请空间的数据在堆区



2. 填空题：

  sizeof(num1) = __40__;//数组大小,10个整形数据一共40字节

  sizeof(char2) = __5__;//包括\0的空间

  strlen(char2) = __4__;//不包括\0的长度

  sizeof(pChar3) = __4__;//pChar3为指针

  strlen(pChar3) = __4__;//字符串“abcd”的长度，不包括\0的长度

  sizeof(ptr1) = __4__;//ptr1是指针

--------------------------------------------------------------------------------------------------------------------------------

下面有关c++内存分配堆栈说法错误的是( )


A.对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制
B. 对于栈来讲，生长方向是向下的，也就是向着内存地址减小的方向；对于堆来讲，它的生长方向是向上的，是向着内存地址增加的方向增长
C.对于堆来讲，频繁的 new/delete 势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题
D.一般来讲在 32 位系统下，堆内存可以达到4G的空间，但是对于栈来讲，一般都是有一定的空间大小的

答案

A.栈区主要存在局部变量和函数参数，其空间的管理由编译器自动完成，无需手动控制，堆区是自己申请的空间，在不需  要时需要手动释放

B.栈区先定义的变量放到栈底，地址高，后定义的变量放到栈顶，地址低，因此是向下生长的，堆区则相反

C.频繁的申请空间和释放空间，容易造成内存碎片，甚至内存泄漏，栈区由于是自动管理，不存在此问题

D.32位系统下，最大的访问内存空间为4G,所以不可能把所有的内存空间当做堆内存使用，故错误

内置类型与自定义类型动态数组释放

使用 char* p = new char[100]申请一段内存，然后使用delete p释放，有什么问题？( )


作业内容
A.会有内存泄露
B.不会有内存泄露，但不建议用
C.编译就会报错，必须使用delete []p
D.编译没问题，运行会直接崩溃

答案

A.对于内置类型，此时delete就相当于free，因此不会造成内存泄漏

B.正确

C.编译不会报错，建议针对数组释放使用delete[],如果是自定义类型，不使用方括号就会运行时错误

D.对于内置类型，程序不会崩溃，但不建议这样使用

多申请单析构后果

ClassA *pclassa=new ClassA[5];

delete pclassa;

c++语言中，类ClassA的构造函数和析构函数的执行次数分别为( )
A.5,1
B.1,1
C.5,5
D.程序可能崩溃

答案

A.申请对象数组，会调用构造函数5次，delete由于没有使用[]，此时只会调用一次析构函数，但往往会引发程序崩溃

B.构造函数会调用5次

C.析构函数此时只会调用1次，要想完整释放数组空间，需要使用[]

D.正确

C++中关于堆和栈的说法，哪个是错误的:( )

A.堆的大小仅受操作系统的限制，栈的大小一般较小
B.在堆上频繁的调用new/delete容易产生内存碎片，栈没有这个问题
C.堆和栈都可以静态分配
D.堆和栈都可以动态分配

答案

A.堆大小受限于操作系统，而栈空间一般有系统直接分配

B.频繁的申请空间和释放空间，容易造成内存碎片，甚至内存泄漏，栈区由于是自动管理，不存在此问题

C.堆无法静态分配，只能动态分配

D.栈可以通过函数_alloca进行动态分配，不过注意，所分配空间不能通过free或delete进行释放

模板初阶

函数模板

使用方法

template<type name T>

sawp(T a, Tb)

{}

调用：

 不指定T，编译器根据参数类型实例化T

 指定T，显示实例化T

同名普通函数和模板可同时存在

匹配原则：优先匹配最相似的

但T不出现在参数时，必须显示指定T类型

T不同时，调用同一模板，但不是同一函数

类模板

 类模板必须显式实例化

 类成员函数声明定义分离时，要在每个含T函数前加template <....>

 模板不建议声明定义分离到cpp和h，会链接错误，大大增加编译时间

类模板与模板类

类模板是一个类家族，模板类是通过类模板实例化的具体类

类模板中的函数

类模板中的成员函数全是模板函数，类外定义时都要加template <typename T>

#include <iostream>
using namespace std;

template <typename T>
class D{
	public:
	void add();
};

template <typename T>
void D<T>::add()
{
	T a;
	cout<<"进入add"<<endl;
}


int main()
{
	D<int> d;
	d.add();
	return 0;
}