C/C++ 的一些乱七八糟的总结（一）

最新推荐文章于 2024-08-14 22:29:49 发布
最新推荐文章于 2024-08-14 22:29:49 发布
阅读量106 收藏
点赞数
文章标签： c/c++ 内存管理

0.最近在复习C++，好多东西都忘了 ==！！ 

从博客中，书中看到的一些东西，在这里简单总结下，没有章法，看到哪，复习到哪


1. 引用

  C++中引用 具备了 指针的 所有功能

   区别：

  （1） 引用在定义时必须初始化.引用和变量共享同一块内存空间，而指针单独有内存空间

   （2） 指针进行删除后，一般需要将其指向NULL，防止野指针，而引用至始而终都是它初始化时的地址，而且也不用删除，它会在作用域范围外由系统回收

 引用和它引用的变量指向的是同一块内存空间                                

image

   当修改其中任意一个值时，两个值都改变，当对引用重新赋一个新值时，引用的值和原来引用指向的值都改变为这个新值，而引用地址不变

捕获

在C ++ 中还可以定义一个类的对象的引用，与对象共享一块内存

     C++中 3  种传递函数参数的方式

   （1）按值传递

    （2）引用传递

     （3）指针传递

3种方式的示例代码如下：

#include <iostream>

using namespace std;

void f(int a)
{
    a = 10;
    cout << "函数f()中 a = " << a << endl;
}
void g(int * a)
{
    *a = 15;
    cout << "函数g() 中 a = " << *a << endl;
}
void h(int &a)
{
    a = 20;
    cout << "函数h() 中 a  = " << a << endl;
}
int main()
{
    int a = 1;
    cout << "按值传递前 a = " << a << endl;
    f(a);
    cout << "按值传递后 a = " << a << endl;
    cout << "按地址传递前 a  = " << a << endl;

    g(&a);
    cout << "按地址传递后 a = " << a << endl;
    cout << "按引用传递前 a = "  << a << endl;
    h(a);
    cout << "按引用传递后 a = " << a << endl;

    return 0;
}

　　

可以看到按值传递，函数f()是不能修改a的

因为按值传递,只是把主函数a的值给了f函数的a值,这两个a的地址不是同一个地址,

在执行的过程中,会把主函数a的地址的数据拷贝给set函数a的地址

2 c++ 内存管理

  内存分配方式

   1. 从静态区分配,一般是全局变量和static类型变量

   2.从栈区分配内存,一般是局部的变量,会随着所在函数的结束而自动释放

   3.从堆中分配,一般是使用手动分配,使用malloc()函数和new来申请任意大小空间,不过要手动释放空间,相应的使用free()函数和delete释放,

    如果不释放该空间,而且指向该空间的指针指向了别的空间.则该空间就无法释放,造成内存泄露,造成了内存浪费

动态内存释放问题与野指针

当我们使用free()和delete释放一块内存时,指针还是指向原来的地址,不过这时候的指针时野指针

1.指针销毁了,并不表示所指的空间也得到了释放 :内存泄露

2.内存被释放了,并不表示指针也被销毁了或指向NULL :野指针

示例代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;

int main()
{
    char *p = (char *)malloc(100);
    memset(p,0,10);//一般申请内存后，最好使用memset初始化一下
    strcpy(p,"hello world!");
    if(p)
    {
        cout << "p:" << p << endl;
    }

    free(p);
    // 所谓的野指针
    cout << "p:" << p << endl;
    if(p != NULL)
    {
        cout << "p不为空!" << endl;
    }
    p = NULL;


    return 0;
}

　　

指针的内存的传递

ContractedBlock.gif ExpandedBlockStart.gif View Code 
#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

// 返回内存地址方式，这是正确的 ！
//因为是动态内存分配，在堆上分配的
char * getMemory()
{
char  *p = NULL;
    p = (char *)malloc(sizeof(char));
    memset(p,0,sizeof(char));
return p;
}
//常见错误是在栈上分配的被返回了，错误的
char *getMemory2()
{
char p [] = "hello world";
return p;
}
//通过指针的指针方式申请内存
void getMemory3(char ** p)
{
*p = NULL;
*p = (char *)malloc(sizeof(char));
if(*p)
    {
        cout << "p:" << p << endl;
    }
}


int main()
{
char *p1 = NULL;
char *p2 = NULL;
char *p3 = NULL;

    p1 = getMemory();
if(p1)
    {
        cout << "p1申请成功!" << endl;
    }

     p2  = getMemory2();
if(p2)
     {
         cout << "p2申请成功！" << endl;
         cout << "p2:" << p2 << endl;
     }


    getMemory3(&p3);
if(p3)
    {
        cout << "p3申请成功!" << endl;
    }
return 0;
}

3 动态数组（从csdn还是cnblogs中看到的，直接在这贴吧，网址找不到了）

  1维

#include <stdio.h>
#include <stdlib.h>
int main()
{
int n1,i;
int *array;
printf("请输入所要创建的一维动态数组的长度：");
scanf("%d",&n1);
array=(int*)calloc(n1,sizeof(int));
for(i=0;i<n1;i++)
{
 printf("%d\t",array[i]);
}
printf("\n");
for(i=0;i<n1;i++)
{
 array[i]=i+1;
 printf("%d\t",array[i]);
}
 free(array);//释放第一维指针
return 0;
}

　　2维

#include <stdio.h>
#include <stdlib.h>
int main()
{
int n1,n2;
int **array,i,j;
printf("请输入所要创建的动态数组的第一维长度：");
scanf("%d",&n1);
printf("请输入所要创建的动态数组的第二维长度：");
scanf("%d",&n2);
array=(int**)malloc(n1*sizeof(int*)); //第一维
for(i=0;i<n1; i++)
{
array[i]=(int*)malloc(n2* sizeof(int));//第二维
}
for(i=0;i<n1;i++)
{
for(j=0;j<n2;j++)
{
array[i][j]=i*n2+j+1;
printf("%d\t",array[i][j]);
}
printf("\n");
}
for(i=0;i<n1;i++)
{
free(array[i]);//释放第二维指针
}
free(array);//释放第一维指针
return 0;
}

　　3维

#include <stdlib.h>
#include <stdio.h>
int main()
{
int n1,n2,n3;
int ***array;
int i,j,k;
printf("请输入所要创建的动态数组的第一维长度：");
scanf("%d",&n1);
printf("请输入所要创建的动态数组的第二维长度：");
scanf("%d",&n2);
printf("请输入所要创建的动态数组的第三维长度：");
scanf("%d",&n3);
array=(int***)malloc(n1*sizeof(int**));//第一维
for(i=0; i<n1; i++)
{
array[i]=(int**)malloc(n2*sizeof(int*)); //第二维
for(j=0;j<n2;j++)
{
array[i][j]=(int*)malloc(n3*sizeof(int)); //第三维
}
}
for(i=0;i<n1;i++)
{
for(j=0;j<n2;j++)
{
for(k=0;k<n3;k++)
{
array[i][j][k]=i+j+k+1;
printf("%d\t",array[i][j][k]);
}
printf("\n");
}
printf("\n");
}
for(i=0;i<n1;i++)
{
for(j=0;j<n2;j++)
{
free(array[i][j]);//释放第三维指针
}
}
for(i=0;i<n1;i++)
{
free(array[i]);//释放第二维指针
}
free(array);//释放第一维指针
return 0;
}

　　更多的维度也能照此写出来

   使用recolloc进行数组的扩大或者缩小：

   扩大

#include <stdio.h>
#include <stdlib.h>
int main()
{
int*n,*p;
int i,n1,n2;
printf("请输入所要创建的动态数组的长度：");
scanf("%d",&n1);
n=(int*)calloc(n1,sizeof(int));
printf("请输入所要扩展的动态数组的长度：");
scanf("%d",&n2);
p=(int*)realloc(n,(n2)*sizeof(int));//动态扩充数组
for(i=0;i<n2;i++)
{
p[i]=i+1;
if(i%5==0)
printf("\n");
printf("%d\t",p[i]);
}
free(p);
return 0;
}

　　缩小

#include <stdio.h>
#include <stdlib.h>
int main()
{
int*n,*p;
int i,n1,n2;
printf("请输入所要创建的动态数组的长度：");
scanf("%d",&n1);
n=(int*)calloc(n1,sizeof(int));
for(i=0;i<n1;i++)
{
n[i]=i+1;
if(i%5==0)
printf("\n");
printf("%d\t",n[i]);
}
printf("\n请输入所要缩小的动态数组的长度：");
scanf("%d",&n2);
p=(int*)realloc(n,(n2)*sizeof(int));
for(i=0;i<n2;i++)
{
if(i%5==0)
printf("\n");
printf("%d\t",p[i]);
}
printf("\n");
free(p);
return 0;
}

　　

4.  sizeof（）

   

#include <iostream>
#include <stdio.h>
using namespace std;
 //linux内核链表里的一个宏
 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)4)->MEMBER)


typedef struct stu1
{
    int a;
    int b;
}stu1;
void print()
{
    cout << "hello world" << endl;
}
int print2()
{
    cout << "hello world" << endl;
    return  1;
}




#pragma pack (1) /*指定按1字节对齐*/

typedef union stu
{
	char str[10];
	int b;
}stu;

#pragma pack () /*取消指定对齐，恢复缺省对齐*/

typedef union stu2
{
	char str[10];
	int b;
}stu2;




int main()
{
    int i;
    //sizeof可以对一个表达式求值，编译器根据表达式的最终结果确定大小
    //但是不会对表达式进行计算，不会对函数进行执行
	printf("sizeof(i):\t%d\n",sizeof(i));
	printf("sizeof(4):\t%d\n",sizeof(4));
	printf("sizeof(4+2.5):\t%d\n",sizeof(4+2.5));
	printf("sizeof(int):\t%d\n",sizeof(int));
	printf("sizeof 5:\t%d\n",sizeof 5);

	cout << "============================" << endl;
    //对于void类型，其长度为1
    cout << sizeof(print()) << endl;
  //int型的返回值，其长度为4（都是在32位机器）
    cout << sizeof(print2()) << endl;



    cout << "============================" << endl;
    printf("offsetof(stu1,a):%d\n",offsetof(stu1,a)-4);
    cout << "ofsetof(stu1,a):" << offsetof(stu1,a) - 4 << endl;
    printf("offsetof(stu1,b):%d\n",offsetof(stu1,b)-4);



    cout << "============================" << endl;
     printf("sizeof(stu)    :\t%d\n",sizeof(stu));
    printf("sizeof(stu2)    :\t%d\n",sizeof(stu2));


    return 0;
}

　　对于结构体：

#include <stdio.h>

typedef struct stu1
{
	char array[7];
}stu1;

typedef struct stu2
{
	double fa;
}stu2;

typedef struct stu3
{
	stu1 s;
	char str;
}stu3;

typedef struct stu4
{
	stu2 s;
	char str;
}stu4;

typedef struct stu5
{
    double d1;
    int i1;
    char c1;
}stu5;

typedef union stu6
{
    double d1;
    int i1;
     char c1;
}stu6;

typedef struct stu7
{
    char c1;
    int i1;
    double d1;
}stu7;

typedef struct stu8
{
    int i1;
    char c1;
    double d1;
}stu8;


int main()
{
	printf("sizeof(stu1)    :\t%d\n",sizeof(stu1));
	printf("sizeof(stu2)    :\t%d\n",sizeof(stu2));
	printf("sizeof(stu3)    :\t%d\n",sizeof(stu3));
	printf("sizeof(stu4)    :\t%d\n",sizeof(stu4));
	printf("sizeof(stu5)    :\t%d\n",sizeof(stu5));
	printf("sizeof(stu6)    :\t%d\n",sizeof(stu6));
	printf("sizeof(stu7)    :\t%d\n",sizeof(stu7));
	printf("sizeof(stu8)    :\t%d\n",sizeof(stu8));
	return 0;
}

　　size_t ，对于大小的比较，或者其他计算，会变成其补码形式

#include <iostream>

using namespace std;

int main()
{
    size_t a = -1;
    size_t b = 10;
    if(a<b)
    cout << "a < b" << endl;
    else
    cout << "a !< b" << endl;
    return 0;
}

　　答案是 a !< b


5 一道堆栈指针问题

#include <iostream>

using namespace std;

//指针的地址是在栈中（首地址除外），但是指针指向的内容却在堆中，
//所以并没有被清除

char* get_str()
{
    char* str = {"abcd"};
     return str;
}
//栈里面的变量都是临时的。当前函数执行完成时，
//相关的临时变量和参数都被清除了,所以返回的指针指向的已经是随机的了
//但是str[]首地址被当成指针来处理，存放在堆中。
char* get_str2()
{
    char str[] = {"abcd"};
     return str;
}
int main(int argc, char* argv[])
{
    char* p = get_str();
    cout << *p << endl;
    cout << *(p+1) << endl;
    cout << p << endl;
    cout << "========================" << endl;

    char *p2 = get_str2();
    //第1次执行 *p2的时候，由于p2指针的首地址被返回了，还是可以取到*p2的内容的
    /*
      可以试试取*(p2+1),也是可以取到的
    */
    cout << *p2 << endl;
   
    //第一次调用*p2的时候还是有数据的，但是第2次就没有了，
    //说明cout之后指针已经被破坏了
    cout << *p2 << endl;
    cout << *(p2+1) <<endl;
    cout << *p2 << endl;
    cout << p2 << endl;
     return 0;
}

　　

　　参考：整理自互联网

http://blog.csdn.net/bizhu12/article/details/6668834

http://blog.csdn.net/bizhu12/article/details/6666176

http://blog.csdn.net/bigloomy/article/category/840249

weixin_34203426
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c/c++帮助文档中文
04-03
C/C++是两种广泛使用的编程语言，特别是在系统编程、嵌入式开发以及高性能计算领域。这份"c/c++帮助文档中文"提供了丰富的中文资源，帮助...无论你是哪个阶段的C/C++程序员，这份中文文档都将是一份宝贵的参考资料。
c语言/c++代码编辑器Dev-C 5.11
08-09
Dev-C++是一款免费、开源、轻量级的C/C++集成开发环境（IDE），专为学习及小型项目开发设计。它集成了代码编辑、编译、调试等功能于一体，界面友好，操作简便，适合从入门到进阶的编程爱好者使用。支持多种编译器...
Ｃ++的那些乱七八糟的错误
lvxingang的专栏
04-26 688
1. 命名空间函数冲突 #include using namespace std; //using std::cout; //using std::endl; template T max(T m1, T m2) { return (m1 > m2) ? m1 : m2; } int main() { cout << max(2, 5) << endl; return 0; } 你看
C/C++懂的人很多，精通的人却寥寥无几
qq_45067397的博客
05-14 938
初级别晓海的技术
C语言动态内存管理和柔性数组
qq_55546526的博客
04-04 508
1.动态内存管理 为什么要存在动态内存分配？ 有时候我们需要的空间大小在程序运行的时候才能知道， 那数组的编译时开辟空间的方式就不能满足了。 这时候就只能试试动态存开辟了。 1.1malloc malloc是C语言动态开辟空间的函数，但是没有初始化的功能 用一段代码来举例子 ptr = (int*)malloc(num*sizeof(int)); 这段代码的意思是给num开辟一个大小位num*int的一个空间，并且把其实地址赋值给指针ptr 详细解读一下 malloc(n.
C/C++语言编程规范
陈七的博客，学习知识分享，期待与大家的交流
12-28 579
C/C++语言编程规范，全方位介绍布局、排版规则及命名、注释等编程规范。个人编程习惯的总结。
CVTE C/C++研发实习面试（凉）
qq_42120843的博客
12-04 1152
CVTE C/C++研发 面试记录
二维码（QRcode）生成算法 C语言/C++源码
02-11
#二维码（QRcode）生成算法 C语言/C++ 源码 1. 根据输入字符串识别编码模式； 2. 根据输入字符串长度选择合适的QRcode版本； 3. 将编码转换为二进制位流表示为数据码字； 4. 使用多项式生成纠错码； 5. 将数据码和...
C语言/C++基础之冰墩墩源码
12-20
C语言/C++基础之冰墩墩源码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
C语言/C++基础之爱心源码
12-20
C语言/C++基础之爱心源码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
C++20 要来了！
大数据
12-11 4508
导读：C++的新标准又双叒叕要到来了，是的，C++20要来了！本文经授权转自公众号CSDN（ID：CSDNnews），作者：祁宇▲图片来源：udemy.com几周前，C+...
C语言-内存管理基础
王昌时的博客
07-02 518
前言 C语言作为一门应用途广泛、功能强大、使用灵活的面向过程式编程语言。既可用于编写应用软件，又能用于编写系统软件。所以深入理解C语言的内存管理能够加深我们对程序的理解，有助于开发出更高质量的应用。本文...
C/C++陷阱与套路
沉迷单车的追风少年
07-23 665
一、导语 C++是一门被广泛使用的系统级编程语言，更是高性能后端标准开发语言；C++虽功能强大，灵活巧妙，但却属于易学难精的专家型语言，不仅新手难以驾驭，就是老司机也容易掉进各种陷阱。 本文结合作者的工作经验和学习心得，对C++语言的一些高级特性，做了简单介绍；对一些常见的误解，做了解释澄清；对比较容易犯错的地方，做了归纳总结；希望借此能增进大家对C++语言了解，减少编程出错，提升工作效率。 二、陷阱 我的程序里用了全局变量，为何进程退出会莫名其妙的core掉？ Rule：C++在不同模块（源文件）
为什么多数游戏服务端是用 C++ 来写
weixin_33749242的博客
10-28 820
早年开发游戏必须用C++，这没得说，2000-2004年，java还没有nio，其他动态语言不抗重负，只能C/C++能开发出完整可用的游戏服务端。直到2005年，韩国的游戏很多都还是纯C++写服务端，金山之前也开发过很多纯粹C++的游戏服务端，后来大家都切了。现代选择有很多：java + javascript, c+python, c+lua, scala, go, erlang。我们面向性能...
C/C++开发，opencv内置背景减除算法与运动检测
最新发布
技术需要分享
08-14 956
C/C++开发，opencv内置背景减除算法的完整代码及编译过程示例
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值