C/C++开发，无可避免的内存管理（篇二）-约束好跳脱的内存

已于 2023-03-15 00:10:01 修改
阅读量766 收藏 2
点赞数
分类专栏： c/c++开发进阶及实战案例 文章标签： c++ c语言 内存对齐 内存管理 内存泄漏
于 2023-02-24 17:54:05 首次发布
本文为CSDN“py_free-物联智能”博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/py8105/article/details/129197714
版权
文章详细讨论了C++中内存管理的重要习惯，包括动态对象的创建、释放、内存对齐以及使用智能指针避免内存泄漏。强调了初始化动态对象、控制内存回收逻辑、正确分配内存大小和初始化的重要性。此外，还介绍了内存对齐的概念，解释了编译器如何进行效率优化以及如何自定义对齐模数。
摘要由CSDN通过智能技术生成

目录

一、养成内存管理好习惯

        1.1 养成动态对象创建、调用及释放好习惯

        1.2 控制好内存在各分支逻辑上的回收

        1.3 确保为动态对象分配了合适的内存

          1.4 为动态对象做合适的初始化      

        1.5 const对象动态分配

        1.6 dynamic_cast向下转型时内存错误

        1.7 千万不要返回局部对象的引用

二、 内存对齐

        2.1 内存对齐是编译器的效率优化要求

        2.2 自行设置对齐模数

三、本文源代码        

一、养成内存管理好习惯

        1.1 养成动态对象创建、调用及释放好习惯

        开发者手动接管内存分配时，必须处理这两个任务。分配原始内存时，必须在该内存中构造对象；在释放该内存之前，必须保证适当地撤销这些对象。如果你的项目是c++项目，就采用new和delelte操作符来管理动态对象，就尽量不要掺杂malloc和free函数行为；如果是c项目，就不要习惯性地又掺杂new和delelte操作符。

        C++ 中，使用 new表达式的时候，分配内存，并在该内存中构造一个对象：使用 delete 表达式的时候，调用析构函数撤销对象，并将对象所用内存返还给系统。

        在动态创建对象时，尽可能明确指定其数据类型，并及时初始化，采用new 表达式返回指向新创建对象的指针，明确指针指向内容大小，通过该指针即可来访问此对象。

	int iv[2] = {1,2};
	//int *p1i = NULL; p1i = iv;          //不建议分开
	int *p1i = iv;                        //建议一步到位
	//int *p2i = NULL; p2i = new int(2);  //不建议分开
	int *p2i = new int(2);                //建议一步到位
	//char* pc = NULL; pc =(char*)malloc(2);//不建议分开
	char* pc = (char*)malloc(2);          //建议一步到位

        对未构造的内存中的对象进行赋值而不是初始化，其行为是未定义的。对许多类而言，这样做引起运行时崩溃。赋值涉及删除现存对象，如果没有现存对象，赋值操作符中的动作就会有灾难性效果。

        在使用动态对象前，养成习惯性判断对象是否合法的习惯，毕竟内存分配失败、对象已经本删除、对象没初始化都是会发生的事，判断语句表达式最好是null在前：

void func(int *pi)
{
    assert(NULL!=pi);        //函数的入口校，使用前先判断
    //do something
	std::cout << "*pi = " << *pi <<"\n";
	int *pi_new = new int(100);
	if(NULL==pi_new) return;	//非参数的地方使用
	//do something
}

int main(int argc, char* argv[])
{
    int iv[2] = {1,2};
	//int *p1i = NULL; p1i = iv; //不建议分开
	int *p1i = iv;            //建议一步到位
	if(NULL!=p1i)    //使用前先判断
		std::cout << "*p1i = " << *p1i <<"\n";
    if(NULL!=(p1i+1))//使用前先判断
		std::cout << "*(p1i+1) = " << *(p1i+1) <<"\n";
	//int *p2i = NULL; p2i = new int(2); //不建议分开
	int *p2i = new int(2);            //建议一步到位
	if(NULL!=p2i)    //使用前先判断
		std::cout << "*p2i = " << *p2i <<"\n";
	//char* pc = NULL; pc =(char*)malloc(2);//不建议分开
	char* pc = (char*)malloc(2);          //建议一步到位
	if(NULL!=pc)        //使用前先判断
		*pc= 'a'; 
	if(NULL!=(pc+1))    //使用前先判断
		*(pc+1) = 'b';
	if(NULL!=pc)        //使用前先判断
		std::cout << "*pc = " << *pc <<"\n";
	
	func(p1i);
    //other code
    return 0;
}

        在释放动态对象时，习惯把指针重新指向NULL，防止野指针(悬垂指针)出现，野指针往往导致程序错误，而且很难检测出来：

int iv[2] = {1,2};
int *p1i = iv;            //建议一步到位
//delete p1i;            //error: p1i refers to a local val
//free(p1i);             //error: p1i refers to a local val
p1i = NULL;              //不再使用时,重新指向对象指针为NULL

int *p2i = new int(2);
delete p2i; p2i = NULL;//删除动态对象时，立刻重指向对象指针为NULL
	
char *pc = (char*)malloc(2);
free(pc); pc = NULL;	//释放动态对象时，立刻重指向对象指针为NULL

       对于容器类指针也是如此，指向引用对象的指针不允许进行对象删除，只能管理好自己的赋值操作。

//
	std::cout << "vector test\n";
	std::vector<std::string> svec(10);
	std::vector<std::string> *pvec1 = new std::vector<std::string>(10);
	std::vector<std::string> *pv1 = &svec;
	std::vector<std::string> *pv2 = pvec1;

	delete pvec1;
	pvec1 = NULL;
	//delete pv1;	//error
	pv1 = NULL;
	//delete pv2;	//error
	pv2 = NULL;

         另外删除null指针也是可以的，虽然这样做没什么意义：

int *ip = NULL;
delete ip;     //OK
//ip = NULL;

        1.2 控制好内存在各分支逻辑上的回收

        警惕动态对象应用时，逻辑分支绕开动态对象释放，造成内存泄漏。例如下面示例：

void func1(void)
{
	try{
		int *pi_new = new int(100);
		if(NULL==pi_new) return;	//非参数的地方使用
		//1 do something,这里出现异常,将跳转到2,后面的对象释放将被绕开，造成内存泄漏
		delete pi_new;
		pi_new = NULL;
	}catch(...)
	{
		//2 do something
	}
};

//建议
void func2(void)
{
	int *pi_new = new int(100);
	if(NULL==pi_new) return;	//非参数的地方使用
	try{
		//1 do something
	}catch(...)
	{
		//2 do something
	}
	if(NULL!=pi_new)
	{
		delete pi_new;
		pi_new = NULL;
	}
};

        如果编译器版本支持智能指针的话，为了避免逻辑分支引起动态对象内存释放失败，建议采用智能指针替代：

void func3(void)
{
	std::auto_ptr<int> pai(new int(100));//只要函数调用结束，就自动释放
	try{
		std::cout << "*pai = " << *pai << "\n";
		//1 do something
	}catch(...)
	{
		//2 do something
	}
};

        但要注意智能指针的使用，把握好智能指针为处理动态分配的内存提供了安全性和便利性的尺度。

  1. 不要使用 auto_ptr 对象保存指向静态分配对象的指针，否则，当 auto_ptr 对象本身被撤销的时候，它将试图删除指向非动态分配对象的指针，导致未定义的行为。
  2. 永远不要使用两个 auto_ptrs 对象指向同一对象，导致这个错误的一种明显方式是，使用同一指针来初始化或者 reset 两个不同的 auto_ptr 对象。另一种导致这个错误的微妙方式可能是，使用一个 auto_ptr 对象的 get 函数的结果来初始化或者 reset另一个 auto_ptr 对象。
  3. 不要使用 auto_ptr 对象保存指向动态分配数组的指针。当auto_ptr 对象被删除的时候，它只释放一个对象—它使用普通delete 操作符，而不用数组的 delete [] 操作符。
  4. 不要将 auto_ptr 对象存储在容器中。容器要求所保存的类型定义复制和赋值操作符，使它们表现得类似于内置类型的操作符：在复制（或者赋值）之后，两个对象必须具有相同值，auto_ptr 类不满足这个要求。

        1.3 确保为动态对象分配了合适的内存

        很多时候，我们定义了指针变量，但是常忘了为指针分配内存，即使得指针没有指向一块合法的内存，尤其是在自定义结构体或类的成员变量包含指针类型时。

class AClass
{
	public:
    //AClass() {};				//pc既没初始化了指针,也没有分配空间,pv没初始化
	//AClass() : pc(NULL){}	    //初始化指针,没有分配空间,pv已经分配了空间,但没有初始化
	AClass() : pc(NULL) {      //初始化指针
		pc = new char[10];     //分配空间
        memset(pv,0,sizeof(pv));//初始化
	};
	~AClass() {
		if(NULL!=pc)	//记得析构函数要手动释放动态对象
		{
			delete[] pc;
            //delete pc;
			//pc = NULL;
		}
        //pv自动释放内存
	}
	char *pc;
    char pv[10];
};

//main函数内
	AClass atest;
	if(NULL!=atest.pc){
		strcpy(atest.pc,"hello");
		std::cout << "*(atest.pc) = " << std::string(atest.pc) <<"\n";
	}

        另外即使给动态内存分配了内存，也要注意在应用时，内存空间是否足够。例如下面代码，为指针分配了内存10，但是应用需要13的内存，内存大小不够，导致出现越界错误，虽然由于指针指向特性及数组连续存储特性，这段代码没有报警，也能运行，但埋下了隐患。

    char str_vec[] = "hello world!";
	std::cout << "sizeof(str_vec) = " << sizeof(str_vec) << "\n";
	if(NULL!=atest.pc){
		strncpy(atest.pc,str_vec,sizeof(str_vec));//越界了，也能完成拷贝
		//strcpy(atest.pc,str_vec);				  //strcpy
		std::cout << "*(atest.pc) = " << std::string(atest.pc) <<"\n";//输出也正常，但安全隐患埋下了
	}
	//
	if(NULL!=atest.pv){                            //转换为指针操作
		strncpy(atest.pv,str_vec,sizeof(str_vec));//越界了，也能完成拷贝
		//strcpy(atest.pv,str_vec);				  //strcpy
		std::cout << "*(atest.pv) = " << std::string(atest.pv) <<"\n";//输出也正常，但安全隐患埋下了
	}

        上述代码越界了，但是由于指针指向特性，并没有告警出现，下面这段代码，是否刷新您的想象。

//
	int vec[10] = {0};//内存分配成功，且已经初始化
	try{
	for(int i=0; i<=10; i++)    //赋值了11次
	{
		vec[i] = i;
	}
	for(int i=0; i<=10; i++)    //遍历了11次
	{
		std::cout << vec[i] << " ";
	}
	std::cout << "\n";
	}catch(...){
		std::cout << "throw!\n";
	}
//out
0 1 2 3 4 5 6 7 8 9 10

        调整打印输出宽度，依然没有报错，那是因为编译器忽略为任何数组形参指定的长度，因此编译没有问题，但是这两个调用都是错误的，可能导致运行可能成功，可能失败，取决于系统的包容都，但数据没有了保证。再调整看看：

//
	int vec[10] = {0};
	try{
	for(int i=0; i<=10; i++)
	{
		vec[i] = i;
	}
	for(int i=0; i<=20; i++)    //调整了这里
	{
		std::cout << vec[i] << " ";
	}
	std::cout << "\n";
	}catch(...){
		std::cout << "throw!\n";
	}
//out log
0 1 2 3 4 5 6 7 8 9 10 1869376613 1919907616 2188396 8367176 1819043176 1870078063 560229490 0 2 6422176

        再调整设值时的宽度

//
	int vec[10] = {0};
	try{
	for(int i=0; i<=30; i++)//调整30
	{
		vec[i] = i;
	}
	for(int i=0; i<=20; i++)//调整20
	{
		std::cout << vec[i] << " ";
	}
	std::cout << "\n";
	}catch(...){
		std::cout << "throw!\n";
	}

        哦，linux下终于给我报错了：

 而win10下依然运行的稳当着：

        但是，不管系统或编译器如何包容，请遵循半闭半开的区间范围-[a,b)写法吧:

//
	int vec[10] = {0};
	try{
	//for(int i=0; i<=20; i++)	//越界不是事
	for(int i=0; i<10; i++)	//请遵循
	{
		vec[i] = i;
	}
	//for(int i=0; i<=20; i++)	//越界不是事
	for(int i=0; i<10; i++)
	{
		std::cout << vec[i] << " ";
	}
	std::cout << "\n";
	}catch(...){
		std::cout << "throw!\n";
	}

          1.4 为动态对象做合适的初始化      

        通常，除了对其赋值之外，对未初始化的对象所关联的值的任何使用都是没有定义的。对于类类型的对象，用该类的默认构造函数初始化；而内置类型的对象则无初始化。如果不提供显式初始化，动态创建的对象与在函数内定义的变量初始化方式相同。但建议创建动态对象时做值初始化。

string *ps = new string; // initialized to empty string
int *pi = new int;       // pi points to an uninitialized
//建议
string *ps = new string(); // initialized to empty string
int *pi = new int();       // pi points to an int value-initialized to 0
class cls{};
cls *pc = new cls();       // pc points to a value-initialized object of type cls

        显式表明通过在类型名后面使用一对内容为空的圆括号，对动态创建的对象做值初始化。内容为空的圆括号表示虽然要做初始化，但实际上并未提供特定的初值。对于提供了默认构造函数的类类型（例如 string），没有必要对其对象进行值初始化：无论程序是明确地不初始化还是要求进行值初始化，都会自动调用其默认构造函数初始化该对象。而对于内置类型或没有定义默认构造
函数的类型，采用不同初始化方式则有显著的差别：

int *pi = new int;   // pi 指向int型变量，该变量未初始化
int *pi = new int(); // pi 指向int型变量，该变量初始化值为0

        1.5 const对象动态分配

        C++ 允许动态创建 const 对象：

    //
	const int* pci = new const int(100);
	//int *p5i = pci;            //error
	int *p5i = (int*)(pci);      //类型转换
	p5i = NULL;
	delete pci;                 //OK: deletes a const object
	pci = NULL;

        与其他常量一样，动态创建的 const 对象必须在创建时初始化，并且一经初始化，其值就不能再修改。上述 new 表达式返回指向 int 型 const 对象的指针。与其他 const 对象的地址一样，由于 new 返回的地址上存放的是 const对象，因此该地址只能赋给指向 const 的指针。

        尽管不能改变 const 对象的值，但可撤销对象本身。如同其他动态对象一样， const 动态对象也是使用删除指针来释放的.

	delete pci;                 //OK: deletes a const object
	pci = NULL;

        对于类类型的 const 动态对象，如果该类提供了默认的构造函数，则此对象可隐式初始化。

//
	const std::string *ps_const = new const std::string;
	delete ps_const;
	ps_const = NULL;

        new 表达式没有显式初始化 ps_const所指向的对象，而是隐式地将 ps_const所指向的对象初始化为空的 string 对象。内置类型对象或未提供默认构造函数的类类型对象必须显式初始化。

        1.6 dynamic_cast向下转型时内存错误

        dynamic_cast 支持运行时识别指针或引用所指向的对象，但是对于从父类转向子类时，稍有不慎就引擎内存错误：

//AClass见前文定义
class BClass : public AClass
{
	public:
	BClass(): AClass(),pbc(NULL)
	{
		pbc = new char[10]; //分配10个字节空间
	};
	~BClass()
	{
		if(NULL!=pbc)	//记得析构函数要手动释放动态对象
		{
            delete[] pbc;
			//delete pbc;
			//pbc = NULL;
		}
		//默认调用~AClass()
	}
	char *pbc;
};

//main函数内
AClass *pa = new AClass();
	BClass *pb = dynamic_cast<BClass*>(pa);
	
	if(NULL!=pb->pbc){//error,本质上是pa,BClass构造函数没被调用,pbc没分配空间及初始化
		strcpy(pb->pbc,"hello");
		std::cout << "*(pb->pbc) = " << std::string(pb->pbc) <<"\n";
	}

        因此强烈建议程序员避免使用强制类型转换，尤其要使用ynamic_cast和reinterpret_cast时，请三思再三思。当然还有旧式的强制类型转换也是如此。

        1.7 千万不要返回局部对象的引用

        前一篇博文就阐述了局部指针变量引起的内存问题，这探讨一下局部对象引用的问题：当函数执行完毕时，将释放分配给局部对象的存储空间。此时，对局部对象的引用就会指向不确定的内存。

const string& mapStr(const string& s)
{
    string ret = s;
    ret += ":";
    return ret; // error: 返回局部对象的引用!
}

        这个函数会在运行时出错，因为它返回了局部对象的引用。当函数执行完毕，字符串 ret 占用的储存空间被释放，函数返回值指向了对于这个程序来说不再有效的内存空间。确保返回引用有效的方法就是，和指针指向一样，确保引用指向在此之前存在的对象，而非局部变量。

二、 内存对齐

        2.1 内存对齐是编译器的效率优化要求

        内存对齐通常都是编译器的职责范围，但C/C++语言的一个特点就是太灵活，太强大，它允许你干预“内存对齐”。缺省情况下，编译器默认将结构、栈中的成员数据进行内存对齐。每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。这个对齐模数要求可以是2^n[0,N)=1,2,4,8,16,32,64...中的一个。一般的编译器默认对齐模数是8。

        对齐模数是8时，一个字或双字操作数跨越了 4 字节边界，或者一个四字操作数跨越了 8 字节边界，被认为是未对齐的，从而需要两次总线周期来访问内存。一个字起始地址是奇数但却没有跨
越字边界被认为是对齐的，能够在一个总线周期中被访问。

       为了提高程序的性能，数据结构（尤其是栈）应该尽可能地在自然边界上对齐。因为，为
了访问未对齐的内存，处理器需要作两次内存访问；然而，对齐的内存访问仅需要一次访问。因此，编译器会将未对齐的成员向后移，将每一个都成员对齐到自然边界上，从而也导致了整个结构的尺寸变大。尽管会牺牲一点空间（成员之间有部分内存空闲），但提高了性能。

typedef struct Struct1
{
    char     c1;
    short    s;
    char     c2;
    int      i;
}Test1;

//
    Test1 t1;
	std::cout << "sizeof(t1) = " << sizeof(t1) << "\n";//sizeof(t1) = 12

        上述结构体的内存大小并不是各成员变量内存大小之和，而是12，这是因为编译器为了内存对齐给成员变量做了后移。下面这段代码打印各个成员变量与结构体首地址的偏移量：

//
	printf("c1 %p, s %p, c2 %p, i %p\n",
		(unsigned long int)(void*)&t1.c1 - (unsigned long int)(void*)&t1,
		(unsigned long int)(void*)&t1.s - (unsigned long int)(void*)&t1,
		(unsigned long int)(void*)&t1.c2 - (unsigned long int)(void*)&t1,
		(unsigned long int)(void*)&t1.i - (unsigned long int)(void*)&t1);
//out log
c1 00000000, s 00000002, c2 00000004, i 00000008

        前面就说到，编译器将未对齐的成员向后移，将每一个都成员对齐到自然边界上，其对齐规则为：

        1）首先是数据成员变量的对齐规则，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的对齐模数和这个数据成员自身长度中，比较小的那个进行，每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍。

        2）然后是结构(或联合)的整体对齐规则，在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。

        3）当#pragma pack的n值等于或超过所有数据成员变量长度的时候，这个n值的大小将不产生任何效果。

        因此上面结构体，对齐模数是8，c1长度1，偏移为0；s长度2，偏移取1时，不能构成长度2的整数倍偏移，所以取偏移2；c2长度1，紧接着s取得偏移4；i长度4，不能紧接着c2取5，而是偏移8，为4的整数倍。整体对齐上，对齐模数是8，最大数据成员长度是4，按4整体对齐。他们的偏移布局如下（1为成员占位）。

t1:111111111111
------------------------------
c1:1*
 s:  11
c2:    1***
 i:        1111

       如果调整一下成员变量的次序，其对齐发生了变化，内存大小也跟着被改变：

typedef struct Struct2
{
    char     c1;
    char     c2;
	short    s;
    int      i;
}Test2;

//
	Test2 t2;
	std::cout << "sizeof(t2) = " << sizeof(t2) << "\n";//sizeof(t2) = 8
	//
	printf("c1 %p, c2 %p, s %p, i %p\n",
		(unsigned long int)(void*)&t2.c1 - (unsigned long int)(void*)&t2,
		(unsigned long int)(void*)&t2.c2 - (unsigned long int)(void*)&t2,
		(unsigned long int)(void*)&t2.s - (unsigned long int)(void*)&t2,
		(unsigned long int)(void*)&t2.i - (unsigned long int)(void*)&t2);
//out log
sizeof(t2) = 8
c1 00000000, c2 00000001, s 00000002, i 00000004

         新的结构体中，每个成员都自然地对齐在自然边界上，避免了编译器自动对齐。其对齐如下：

t1:11111111
------------------------------
c1:1
c2: 1
 s:  11
 i:    1111

        2.2 自行设置对齐模数

        程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。而使用指令#pragma pack ()，编译器将取消自定义字节对齐方式。在#pragma pack (n)和#pragma pack ()之间的代码按我们指定的 n 个字节对齐。

    #pragma pack(2)
	typedef struct Struct3
	{
		char     c1;
		short    s;
		char     c2;
		int      i;
	}Test3;
	Test3 t3;
	std::cout << "sizeof(t3) = " << sizeof(t3) << "\n";//sizeof(t3) = 12
	//
	printf("c1 %p, s %p, c2 %p, i %p\n",
		(unsigned long int)(void*)&t3.c1 - (unsigned long int)(void*)&t3,
		(unsigned long int)(void*)&t3.s - (unsigned long int)(void*)&t3,
		(unsigned long int)(void*)&t3.c2 - (unsigned long int)(void*)&t3,
		(unsigned long int)(void*)&t3.i - (unsigned long int)(void*)&t3);
	#pragma pack()

//out log
sizeof(t3) = 10
c1 00000000, s 00000002, c2 00000004, i 00000006

        上述代码指定对齐模数为2，各个数据成员可以按2的整数倍偏移piany对齐，那么6也能作为自然对齐边界，当i对齐6时，结构体长度为10。数据成员最大长度是4（int型），而对齐模数是2，所以取2做对齐，10是2的整数倍，因此结构体对齐满足，所以综合得到整个结构体的内存大小是10。

三、本文源代码        

        g++ main.cpp -o test

        main.cpp

#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <memory>
#include <stdio.h>

void func(int *pi)
{
    assert(NULL!=pi);	//函数的入口校，使用前先判断
    //do something
	std::cout << "*pi = " << *pi <<"\n";
	int *pi_new = new int(100);
	if(NULL==pi_new) return;	//非参数的地方使用
	//do something
}

void func1(void)
{
	try{
		int *pi_new = new int(100);
		if(NULL==pi_new) return;	//非参数的地方使用
		//1 do something,这里出现异常,将跳转到2,后面的对象释放将被绕开，造成内存泄漏
		delete pi_new;
		pi_new = NULL;
	}catch(...)
	{
		//2 do something
	}
};

void func2(void)
{
	int *pi_new = new int(100);
	if(NULL==pi_new) return;	//非参数的地方使用
	try{
		//1 do something,这里出现异常,将跳转到2,后面的对象释放将被绕开，造成内存泄漏
	}catch(...)
	{
		//2 do something
	}
	if(NULL!=pi_new)
	{
		delete pi_new;
		pi_new = NULL;
	}
};

void func3(void)
{
	std::auto_ptr<int> pai(new int(100));//只要函数调用结束，就自动释放
	try{
		std::cout << "*pai = " << *pai << "\n";
		//1 do something
	}catch(...)
	{
		//2 do something
	}
};

class AClass
{
	public:
	//AClass() {};				//pc既没初始化了指针,也没有分配空间,pv没初始化
	//AClass() : pc(NULL){};	//初始化指针,没有分配空间,pv已经分配了空间,但没有初始化
	AClass() :pc(NULL) { 	//
		pc = new char[10]; //分配10个字节空间
		memset(pv,0,sizeof(pv));//初始化
	};
	virtual ~AClass() {
		if(NULL!=pc)	//记得析构函数要手动释放动态对象
		{
			delete[] pc;
		}
		//pv自动释放内存
	}
	char *pc;
	char pv[10];
};

class BClass : public AClass
{
	public:
	BClass(): AClass(),pbc(NULL)
	{
		pbc = new char[10]; //分配10个字节空间
	};
	~BClass()
	{
		if(NULL!=pbc)	//记得析构函数要手动释放动态对象
		{
			delete[] pbc;
		}
		//默认调用~AClass()
	}
	char *pbc;
};
//内存对齐
typedef struct Struct1
{
    char     c1;
    short    s;
    char     c2;
    int      i;
}Test1;

typedef struct Struct2
{
    char     c1;
    char     c2;
	short    s;
    int      i;
}Test2;

int main(int argc, char* argv[])
{
	int iv[2] = {1,2};
	//int *p1i = NULL; p1i = iv; //不建议分开
	int *p1i = iv;            //建议一步到位
	if(NULL!=p1i)
		std::cout << "*p1i = " << *p1i <<"\n";
	if(NULL!=(p1i+1))
		std::cout << "*(p1i+1) = " << *(p1i+1) <<"\n";
	//int *p2i = NULL; p2i = new int(2); //不建议分开
	int *p2i = new int(2);            //建议一步到位
	if(NULL!=p2i)
		std::cout << "*p2i = " << *p2i <<"\n";
	//char* pc = NULL; pc =(char*)malloc(2);//不建议分开
	char* pc = (char*)malloc(2);          //建议一步到位
	if(NULL!=pc)
		*pc= 'a'; 
	if(NULL!=(pc+1))
		*(pc+1) = 'b';
	if(NULL!=pc)
		std::cout << "*pc = " << *pc <<"\n";
	
	func(p1i);
	func2();
	func3();
	//
	p1i = NULL;				//重新指向对象指针为NULL
	delete p2i; p2i = NULL; //删除动态对象时，立刻重指向对象指针为NULL
	free(pc); pc = NULL;	//释放动态对象时，立刻重指向对象指针为NULL
	//
	std::cout << "vector test\n";
	std::vector<std::string> svec(10);
	std::vector<std::string> *pvec1 = new std::vector<std::string>(10);
	std::vector<std::string> *pv1 = &svec;
	std::vector<std::string> *pv2 = pvec1;

	delete pvec1;
	pvec1 = NULL;
	//delete pv1;	//error
	pv1 = NULL;
	//delete pv2;	//error
	pv2 = NULL;
	//
	AClass atest;
	if(NULL!=atest.pc){
		strcpy(atest.pc,"hello");
		std::cout << "*(atest.pc) = " << std::string(atest.pc) <<"\n";
	}
	char str_vec[] = "hello world!";
	std::cout << "sizeof(str_vec) = " << sizeof(str_vec) << "\n";
	if(NULL!=atest.pc){
		strncpy(atest.pc,str_vec,sizeof(str_vec));//越界了，也能完成拷贝
		//strcpy(atest.pc,str_vec);				  //strcpy
		std::cout << "*(atest.pc) = " << std::string(atest.pc) <<"\n";//输出也正常，但安全隐患埋下了
	}
	//
	if(NULL!=atest.pv){
		strncpy(atest.pv,str_vec,sizeof(str_vec));//越界了，也能完成拷贝
		//strcpy(atest.pv,str_vec);				  //strcpy
		std::cout << "*(atest.pv) = " << std::string(atest.pv) <<"\n";//输出也正常，但安全隐患埋下了
	}
	//
	int vec[10] = {0};
	try{
	//for(int i=0; i<=20; i++)	//越界不是事
	for(int i=0; i<10; i++)	//请遵循
	{
		vec[i] = i;
	}
	//for(int i=0; i<=20; i++)	//越界不是事
	for(int i=0; i<10; i++)
	{
		std::cout << vec[i] << " ";
	}
	std::cout << "\n";
	}catch(...){
		std::cout << "throw!\n";
	}
	//
	std::cout << "const ptr test\n";
	const int* pci = new const int(100);
	//int *p5i = pci;            //error
	int *p5i = (int*)(pci);      //类型转换
	p5i = NULL;
	delete pci;                 // ok: deletes a const object
	pci = NULL;
	//
	const std::string *ps_const = new const std::string;
	delete ps_const;
	ps_const = NULL;
	
	AClass *pa = new AClass();
	BClass *pb = dynamic_cast<BClass*>(pa);
	/*
	if(NULL!=pb->pbc){	//error
		strcpy(pb->pbc,"hello");
		std::cout << "*(pb->pbc) = " << std::string(pb->pbc) <<"\n";
	}
	*/
	Test1 t1;
	std::cout << "sizeof(t1) = " << sizeof(t1) << "\n";//sizeof(t1) = 12
	//
	printf("c1 %p, s %p, c2 %p, i %p\n",
		(unsigned long int)(void*)&t1.c1 - (unsigned long int)(void*)&t1,
		(unsigned long int)(void*)&t1.s - (unsigned long int)(void*)&t1,
		(unsigned long int)(void*)&t1.c2 - (unsigned long int)(void*)&t1,
		(unsigned long int)(void*)&t1.i - (unsigned long int)(void*)&t1);
	//
	Test2 t2;
	std::cout << "sizeof(t2) = " << sizeof(t2) << "\n";//sizeof(t2) = 8
	//
	printf("c1 %p, c2 %p, s %p, i %p\n",
		(unsigned long int)(void*)&t2.c1 - (unsigned long int)(void*)&t2,
		(unsigned long int)(void*)&t2.c2 - (unsigned long int)(void*)&t2,
		(unsigned long int)(void*)&t2.s - (unsigned long int)(void*)&t2,
		(unsigned long int)(void*)&t2.i - (unsigned long int)(void*)&t2);
	#pragma pack(2)
	typedef struct Struct3
	{
		char     c1;
		short    s;
		char     c2;
		int      i;
	}Test3;
	Test3 t3;
	std::cout << "sizeof(t3) = " << sizeof(t3) << "\n";//sizeof(t3) = 12
	//
	printf("c1 %p, s %p, c2 %p, i %p\n",
		(unsigned long int)(void*)&t3.c1 - (unsigned long int)(void*)&t3,
		(unsigned long int)(void*)&t3.s - (unsigned long int)(void*)&t3,
		(unsigned long int)(void*)&t3.c2 - (unsigned long int)(void*)&t3,
		(unsigned long int)(void*)&t3.i - (unsigned long int)(void*)&t3);
	#pragma pack()
	return 0;
}

py_free-物联智能
关注
专栏目录
如何优雅地管理C++ 中的内存
记录学习的过程
07-22 766
C++的内存管理 C++是一门Native Language，而说到Native Languages就不得不说资源管理，其中内存管理又是资源管理中的一个大问题，由于堆内存需要手动分配和释放，所以必须确保申请的内存得到正确的释放。对此一般的原则是"谁分配的谁释放"，但即便如此任然会出现内存泄漏，野指针等问题。 托管语言们为了解决这个问题引入了GC（Garbage Collection），它们认为”内...
【C++】dynamic_cast基本用法（详细讲解）
测试开发自动化
08-11 1万+
👉博__主👈：米码收割机👉技__能👈：C++/Python语言👉公众号👈：测试开发自动化【获取源码+商业合作】👉荣__誉👈：阿里云博客专家博主、51CTO技术博主👉专__注👈：专注主流机器人、人工智能等相关领域的开发、测试技术。
[C/C++笔记] dynamic_cast的使用
LPS
06-08 756
dynamic_cast的使用
C++ 标准程序库std::string 详解
CHYabc123456hh的博客
10-02 2万+
现在一般不再使用传统的char*而选用C++标准程序库中的string类，是因为string标准程序和char*比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，集成的操作函数足以完成大多数情况下(甚至是100%)的需要。比如，可以用 = 进行赋值操作，== 进行比较，+ 做串联。尽可以把它看成是C++的基本数据类型。C++是将面向过程的C语言和面向对象的Java语言拼接到一起而组成的一种高级语言。 标准模板库（STL）提供了一个std::string类，其是std::basic_str
C++之const std::string& s（传参时 const string& 相对 const string 的优势）
qq_34706266的博客
03-14 2万+
class DepthViewer : public OpencvViewer { public: DepthViewer(const std::string&amp; win); virtual void show(const cv::Mat&amp; depthImage); virtual void onMouseCallback(cv::Mat&amp; img, ...
C/C++学习笔记六（文件系统、预处理器）
炫目萧萧的专栏
08-06 604
文件系统 文件是指存储在外部存储介质的数据集合（如磁盘光盘等）。操作系统中使用由文件路径和文件名两部分组成的文件标识符来标识文件。 而在C、C++语言中无论是何种文件，都将其看做是一段字节序列。在对其进行读写操作时，以字节流(stream)的方式进行处理。以字节流的方式进行文件操作，很方便的将具体的文件格式都归一为相同流式操作，增强了处理文件的灵活性。 文件缓冲区 ton inlin
13 万字 C 语言从入门到精通保姆级教程2021 年版
热门推荐
李南江
06-07 60万+
13 万字C语言保姆级教程，从入门到精通。
C++11静态断言：编译时错误检查的神器
C++11引入的静态断言机制为编译时的错误检测提供了强大的工具。它允许程序员在编译时期对程序中某些条件进行检查，比如类型特性、模板参数、编译器特定的特性等，以确保这些条件在编译时为真。与运行时的断言相比，...
c++面试题
zhangliang_571的专栏
08-03 8118
1.new、delete、malloc、free关系 delete会调用对象的析构函数,和new对应free只会释放内存，new调用构造函数。malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之
C++primer 12章 动态内存和智能指针
CHYabc123456hh的博客
01-31 392
C++引入智能指针的目的 使用智能指针来管理动态分配的对象，当一个对象应该被释放的时候，指向他的智能指针确保自动释放它 内存分配 静态内存：局部static对象、类static数据成员、定义在任何函数之外的变量 栈内存：定义在函数内的非static对象 分配在静态或者栈内存中的对象由编译器自动创建和销毁 栈对象，仅在其定义的程序块运行时候才会存在 static对象在使用之前就会被分配，程序结束的时候会被销毁 除了静态内存和栈内存，还有一个内存池，被称作自由空间或者叫堆，用来存储动态分配
C++ 避免内存泄漏
Chroniccandy的博客
10-30 1791
内存泄漏 前面我们讲过,分配了一个内存块但是忘记释放这个内存块会导致严重的问题,这样的内存块将等到程序执行结束时才会被释放 如果这个程序运行很长时间(例如服务器,而且不是所有的操作系统都像windows一样每天都可以重启)且这个程序在运行过程中不断的申请新内存块(new),如果此时忘记释放那些已经不在使用的老内存块,老内存块将迟早将内存消耗殆尽,直接导致后边的new操作无法执行和程序崩溃！ 这样的编程漏洞称作内存泄漏(memory leak) 作为 C++ 程序员，内存泄露始终是悬在头上的一颗炸弹。在过去几
C++动态内存管理
一个计算机爱好者学习历程
03-31 3140
问题： 1.string和sizeof的区别 2.malloc、calloc和realloc的区别 3.malloc和new的区别与联系 一、C/C++程序运行起来后，内存分布情况 为什么操做系统设计的时候，需要将完整的内存空间化分成不同的区域？ 方便对内存空间进行管理。 如上图： 1.栈又叫做堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。 2.内存映射段是高效的I/O映射方式，用于装载一个共享内存的动态内存库。用户可使用系统接口创建共享内存，用于进程间通信。
应用软件系统内存限制
wisage的专栏
02-03 1585
申请不到吧，因为64为系统在运行32位程序的时候只是为了向下兼容而已，对于32位程序来讲，申请8G的存储空间没有任何意义，因为32位的程序最大寻址空间只有4G，32位程序在编译之后的机器代码也只有32位的寻址数（指针占4个字节），因此申请8G的空间是没啥意义的，而且一般系统都会为每个进程设置一些资源限制，对于32位程序其能申请的内存量也远远小于4G可以看一下下面这个表操作系统内部数据结构限
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 655
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 74
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
最新发布
caridle的专栏
11-08 361
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 17
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 402
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
算法|牛客网华为机试31-40C++
奇树谦的博客
11-04 724
计算第5次落地后球经过的距离，除了第一次只经过一次，所以距离最后在减去初始长度，高度每次减去一半。for循环遍历一次，从后往前，如果是字符组成单词等遇到空格或者非字母输出。直接用sort函数就是按着ASCII码从小到大排序的。找每行每列的相加差1的数学规律，再每行输出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

py_free-物联智能

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

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

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

打赏作者

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

抵扣说明：

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

余额充值