zoukankan      html  css  js  c++  java

  • CPP数据类型本质以及变量本质分析

    1. //避免在.c里面重复包含多次头文件
    2. #ifndef _CLT_SOCKET2_H__
    3. #define _CLT_SOCKET2_H__
    4.  //...
    5. #endif
    //因为数据类型不一样



    数据类型的本质：
    数据类型可理解为创建变量的模具（模子），是固定内存大小的别名。
    数据类型的作用：
    编译器预算对象（变量）分配的内存空间大小。
    int a[10] = { 1,5,7,9,3,4,6,8,2,0 }; 
    a 与 &a 数据类型不一样，步长不一样 

    typedef int u32;可以为数据类型起别名。

    数据类型封装1
    1、void的字面意思是“无类型”，void *则为“无类型指针”，void *可以指向任何类型的数据。
    2、用法1：数据类型的封装
        int InitHardEnv(void **handle);
         典型的如内存操作函数memcpy和memset的函数原型分别为
    　void * memcpy(void *dest, const void *src, size_t len);
    　void * memset ( void * buffer, int c, size_t num );  
    3、用法2：  void修饰函数返回值和参数，仅表示无。
            如果函数没有返回值，那么应该将其声明为void型
           如果函数没有参数，应该声明其参数为void
           int function(void)
          {return 1;}
    4、void指针的意义 就是把一个不知道数据类型的地址传递过去
          C语言规定只有相同类型的指针才可以相互赋值
          void*指针作为左值用于“接收”任意类型的指针
          void*指针作为右值赋值给其它指针时需要强制类型转换
          int *p1 = NULL;
          Char *p2 = (char *)malloc(sizoeof(char)*20); 
    5、不存在void类型的变量
          C语言没有定义void究竟是多大内存的别名
    6、扩展阅读《void类型详解.doc》


    变量   本质是什么？（一段连续）内存空间的别名，变量是一个标号
    概念：既能读又能写的内存对象，称为变量；若一旦初始化后不能修改的对象则称为常量。
     变量定义形式：     类型  标识符, 标识符, … , 标识符 ; 
    变量本质：（一段连续）内存空间的别名
    1、程序通过变量来申请和命名内存空间 int a = 0
    2、通过变量名访问内存空间

    修改变量有几种方法？
    1、直接
    2、间接。内存有地址编号，拿到地址编号也可以修改内存；于是指针横空出世了！
    3、内存空间可以再取给别名吗？可以取别名，比如C++的引用，引用的本质就是给变量起了个别名，引用和变量的本质不同。

    程序的内存四区模型

    1. void main(){
    2.     int a = 10; //分配4个字节的内存在栈区，栈区也叫临时区
    3.     int *p ;//分配4个字节的内存
    4.     p = &a; //CPU执行的代码，放在代码区
    5.     *p = 20;//
    6.     {
    7.          char *p =NULL;//分配4个字节的内存
    8.          p = (char *)malloc(100);
    9.          if(p != NULL){
    10.              free(p);
    11.          }
    12.     }
    13.       
    14.     system("pause");
    15. }
    流程说明
    1、操作系统把物理硬盘代码load到内存
    2、操作系统把c代码分成四个区
    3、操作系统找到main函数入口执行

    内存四区模型-各个元素分析


    指针变量和它所指向的内存空间变量是两个不同的概念
    指针指向谁，就把谁的地址赋给指针。


    内存四区概念

    函数1调用函数2，函数1称为主调函数 函数2称为被调用函数

    规则1：Main（主调函数）分配的内存（在堆区，栈区、全局区）都可以在被调用函数里使用吧。

    规则2：在被调用函数里面分配的内存

    1、如果在被调用函数里面的临时区（栈）分配内存，主调用函数是不能使用的。

    char * getstring3()

    {

    char buf[30];

    strcpy(buf, "abcde");

    return buf;

    }


    如何建立正确的程序运行内存布局图
    内存四区模型&函数调用模型
    函数内元素 
    深入理解数据类型和变量“内存”属性
    一级指针内存布局图(int *,char*)
    二级指针内存布局图(int ** char **)
    函数间接
    主调函数分配内存，还是被调用函数分配内存
    主调函数如何使用被调用函数分配的内存（技术关键点：指针做函数参数）

    栈的模型生态是开口向下的。堆的模型生态是开口向上。
    Heap、Stack生长方向和内存存放方向是两个不同概念。

    *p 解释： *就像一把钥匙，根据一个指针变量的值，去修改门后面的内存空间。

    指针变量和它指向的内存块是两个不同的概念
    //含义1 给p赋值p=0x1111; 只会改变指针变量值，不会改变所指的内容；p = p +1; //p++
    //含义2 给*p赋值*p='a'; 不会改变指针变量的值，只会改变所指的内存块的值  
    //含义3 =左边*p 表示 给内存赋值， =右边*p 表示取值 含义不同切结！
    //含义4 =左边char *p 
    //含义5 保证所指的内存块能修改

    指针也是一种数据类型，占4个字节
    1. #include "stdio.h"
    2. #include "stdlib.h"
    5. //char *p1 形参 形参也是被调用该函数的参数，只不过具有对外属性而已。
    6. //
    7. void getData01(char *p1)
    8. {
    9. 	printf("getData01() begin
");
    10. 	return ;
    11. }
    13. ////char *p1 形参 是变量
    14. void getData02(char **p2)
    15. {
    16. 	printf("getData01() begin
");
    17. 	return ;
    18. }
    21. ////char *p1 形参 是变量
    22. void getData03(char **p3)
    23. {
    24. 	printf("getData01() begin
");
    25. 	return ;
    26. }
    28. ////char *p7 形参 是变量
    29. void getData07(char *******p7)
    30. {
    31. 	printf("getData01() begin
");
    32. 	return ;
    33. }
    35. /*
    36. //对参数的指针类型应该怎么理解
    37. //理解角度需要从两个角度出发
    38. //站在c/c++编译器的角度 对形参，如果是指针类型，c编译器只会分配四个字节的内存。
    39. ////char *p7 形参 是变量
    41. //指针的数据类型到底是什么
    42. 指针的数据类型是指它所指向的内存空间的数据类型

    44. 指针的数据类型具有依附特性

    46. 结论：指针的步长，根据所指内存空间类型来定。
    49. void senddata01(char    *p1); void senddata01(char*            p1);
    50. void senddata02(char **    p1); void senddata02(char *     *p1);  void senddata02(char         **p1);
    51. void senddata03(char ***p1);
    52. void senddata04(char *p[]); void senddata04(char *     p[]);  void senddata04(char *p    []);
    53. void senddata05(char (*p)[10]); void senddata05(char (*p)             [10]);
    54. void senddata05(char *****p4);
    55. */
    57. void main61()
    58. {
    59. 	char *p1 = NULL;
    60. 	char **p2 = NULL;
    61. 	int  a = 10;
    62. 	
    63. 	int *p3 = NULL;
    64. 	int c = 0;
    66. 	a = 20; //直接通过变量修改a的值
    67. 	p3 = &a; //
    68. 	//*p放在=号的左边，去修改内存空间的值。
    69. 	*p3 = 30; //通过指针间接修改内存空间的值   
    70. 	c = *p3; //*p放在等号的右边从内存空间中拿值
    72. 	/*
    74. 	while(*p != ''')
    75. 	*p1++ = *p2++
    76. 	*/
    78. 	//*p 的意义：*就像一把钥匙，根据一个指针变量的值，去修改门后门的内存空间
    79. 	{
    80. 		char *p2 = 0x0077;
    81. 		*p2 = 100;
    82. 		*((int *)77) =  100;
    83. 	}
    86. 	printf("p2:%d
", sizeof(p2));
    87. 	system("pause");
    88. }
    90. void main63()
    91. {
    92. 	char *p1 = NULL;
    93. 	char *p2 = NULL;
    96. 	char buf1[100] = {0};
    97. 	char buf2[100] = {0};
    98. 	strcpy(buf1, "abcdefg");
    100. 	p1 = buf1;
    101. 	p2 = buf2;
    103. 	while(*p1 != '')
    104. 	{
    105. 		*p2 = *p1;
    106. 		p2++; //p2 向后跳动1个字节
    107. 		p1++;
    108. 	}
    110. }
    112. void main()
    113. {
    114. // 	{
    115. // 		char *p = NULL;
    116. // 		*p = 100;
    117. // 		
    118. // 	}
    120. // 	{
    121. // 		char *p = 0x77;
    122. // 		*p = 100;
    123. // 
    124. // 	}
    126. 	{
    127. 		char *p = "abcdefg";
    128. 		p = 100;
    129. 		printf("%x 
", p);
    130. 		*p = 'z';
    132. 	}
    134. 	system("pause");
    136. }

    //10 字面量，放在不能取地址 没有放在堆栈、全局区，可以按照放在代码区域之类的区域内理解它。
    int *a = &10;
    指针是一种数据类型，是指它指向的内存空间的数据类型。
    含义1：指针步长（p++），根据所指内存空间的数据类型来确定。
    p++ =   -->> (unsigned char)p+sizeof(a);
    结论：指针的步长，根据所指内存空间类型来定、

    通过*p/*p++来改变变量的值是指针存在的最大意义
    1）两码事：指针变量和它指向的内存块的变量
    2）条件反射：指针指向某个变量，就是把某个变    量地址赋给指针
    3）*p间接赋值成立条件：3个条件
        1，2个变量（通常一个实参，一个形参）
        2，建立关系，实参取地址赋给形参指针
        3，*p形参，求间接的修改实参 的值
    1.2.3是指，上述，1，2，3个条件


    1. #include "stdio.h"
    2. #include "stdlib.h"
    3. #include "string.h"
    5. //指针做函数参数
    6. //函数调用过程中，
    7. //用1级指针（通常是形参，）去修改0级指针（通常是实参）的值
    8. //用2级指针（通常是形参，）去修改1级指针（通常是实参）的值
    9. //用3级指针（通常是形参，）去修改2级指针（通常是实参）的值
    10. //用8级指针（通常是形参，）去修改7级指针（通常是实参）的值
    11. //用n级指针（通常是形参，）去修改n-1级指针（通常是实参）的值
    12. int getLen(int *p) {
    13. 	*p = 40; //形参通过地址间接的修改实参的值
    14. 	return 0;
    15. }
    16. /*
    17. 	间接赋值的应用场景有2个
    18. 		1.在函数之内 *p1++ = *p2++
    19. 		2.指针做函数参数，通过*p形参去间接的修改实参的值，这才是指针存在的最大意义
    20. 		这才是C语言特有的现象，才是指针的精华。
    21. */
    22. void main() {
    23. 	int a = 10; //定义了一个变量（实参）
    24. 	int *p = NULL; //定义了一个变量 （形参）
    25. 	a = 20; //直接修改a的值
    26. 	printf("a: %d 
", a);
    27. 	p = &a;//把a的地址赋给p  //把一个变量的地址传递给另外一个变量 //实参取地址传给形参
    28. 	
    29. 	*p = 30;//间接赋值，如果p是a的地址，那么就间接的修改a的值  //*p放在等号的左边
    31. 	printf("a: %d 
" ,a );
    33. 	//p = &a; //a的地址赋给p，把这句话，转成函数调用
    34. 	getLen(&a);
    36. 	printf("a: %d 
", a);
    37. 	system("pause");
    38. }
    //[] *
    //[] -----> *
    //buf[i] --> bur[0+i]  ---> *(p+1) -->p[i]
    //站在C++编译器的角度，*p相当于我们程序猿手工（显示）利用间接赋值，去操作内存
    //[]怎么理解？只不过是C++编译器帮我们程序猿做了*p操作

    *to++ = *from++;先执行*to 再执行++; ++的优先级高于*;
  • 相关阅读:
    闰年测试
    EditBox的测试用例设计
    测试工程中的评审
    测试框架
    github
    第一次上机实验
    对软件测试的初步认识
    白盒测试
    Date : 日期对象
    C++ 格式化输出 及 输入 流
  • 原文地址：https://www.cnblogs.com/litaiqing/p/4615006.html
Copyright © 2011-2022 走看看