精华内容
下载资源
问答
  • 判断地址是指针还是数据
    千次阅读
    2020-08-23 16:35:30

            以32位计算机和32位系统为例。

            变量都必须以某种形式存在内存当中,变量的存储型形式由数据类型来规定,所以在定义变量时,必须是数据类型+变量名。

    数据类型表明这个变量在内存中以什么形式存在。例如  int  a;表明变量在内存中占用4个字节,里面的数据是整数。

             指针是存储地址的变量,而32位系统的地址是32位的,并且地址是正整数,所以指针变量的数据类型是确定的,即unsigned int,无符号整形。因此在指针变量定义时,无需指出指针变量的数据类型。

             但是对于指针变量的定义:数据类型    *指针变量名,前面为什么还有数据类型呢?

             因为指针变量装的内容是一个地址,这个地址的内容的数据类型可以是各种各样的,所以指针变量定义格式中的数据类型是指  指针变量指向的存储单元的数据类型。

            例如 int *p0   float *p1  说的是p0,p1指向的地址的内容是int和float型。而p0,p1本身是无符号整形

            常说指针是一种数据类型。那么到底是哪种数据类型呢?在这里我想,这种数据类型应该就是unsigned in

           上述理解不知是否恰当,希望看到的行家能给予指导,不胜感激。

    sFLASHPRAR是自定义的一种结构体

    定义一个结构体变量,并且初始化:sFLASHPRAR FlashPara = {1,2,3,4,5};

    //定义一个指针pFlashPara,这个指针指向的地址里面装的数据是uint32,而&FlashPara.FlashPara1这个指针里面的内容是uint16,所以需要强制类型转换:
    uint32   *pFlashPara = (uint32 *)(&FlashPara.FlashPara1);
    (uint32 *)(&FlashPara.FlashPara1);的意思是把&FlashPara.FlashPara1指针指向的uint16数据转换成uint32


    //如果想定义一个指针,并且想让这个指针指向变量的FlashPara首地址,应该直接如下定义
    uint16   *pFlashPara = &FlashPara.FlashPara1;

    更多相关内容
  • 深入理解C语言指针

    万次阅读 多人点赞 2019-09-28 08:36:51
    一、指针的概念 ...1.1、变量和地址 先写一段简单的代码: void main(){ int x = 10, int y = 20; } 这段代码非常简单,就是两个变量的声明,分别赋值了 10、20。我们把内存当做一个酒店,而每个房间就...

    一、指针的概念

    要知道指针的概念,要先了解变量在内存中如何存储的。在存储时,内存被分为一块一块的。每一块都有一个特有的编号。而这个编号可以暂时理解为指针,就像酒店的门牌号一样。

    1.1、变量和地址

    先写一段简单的代码:

    void main(){
    	int x = 10, int y = 20;
    }
    

    这段代码非常简单,就是两个变量的声明,分别赋值了 10、20。我们把内存当做一个酒店,而每个房间就是一块内存。那么“int x = 10;”和“int y = 20;”的实际含义如下:

    1. 去酒店订了两个房间,门牌号暂时用 px、py 表示
    2. 让 10 住进 px,让 20 住进 py
    3. 其中门牌号就是 px、py 就是变量的地址
    4. x 和 y 在这里可以理解为具体的房间,房间 x 的门牌号(地址)是 px,房间 y 的门牌号(地址)是 py。而 10 和 20,通过 px、py 两个门牌,找到房间,住进 x、y。用户(变量的值)和房间(变量)以及房间号(指针、地址)的关系

    1.2、指针变量和指针的类型

    指针变量就是一个变量,它存储的内容是一个指针。如果用前面的例子,可以理解为指针变量就是一张房卡,房卡存储了房间号的信息。

    在我们定义一个变量的时候,要确定它的类型。int x、char ch、float、、、在定义指针变量时也是一样的,必须确定指针类型。int 变量的指针需要用 int 类型的指针存储,float 变量的指针需要用 float 类型的指针存储。就像你只能用酒店 A 的房卡存储酒店 A 中房间号的信息一样。

    二、变量的指针与指针变量

    变量的指针就是变量的存储地址,指针变量就是存储指针的变量。

    2.1、指针变量的定义及使用

    (1)指针变量的定义

    指针变量的定义形式如:数据类型 *指针名;例如:

    //分别定义了 int、float、char 类型的指针变量
    int *x;
    float *f;
    char *ch;
    

    如上面的定义,指针变量名为 x、f、ch。并不是*x、*f、*ch

    (2)指针变量的使用

    • 取地址运算符&:单目运算符&是用来取操作对象的地址。例:&i 为取变量 i 的地址。对于常量表达式、寄存器变量不能取地址(因为它们存储在存储器中,没有地址)。
    • 指针运算符*(间接寻址符):与&为逆运算,作用是通过操作对象的地址,获取存储的内容。例:x = &i,x 为 i 的地址,*x 则为通过 i 的地址,获取 i 的内容。

    代码示例:

    //声明了一个普通变量 a
    int a;
    //声明一个指针变量,指向变量 a 的地址
    int *pa;
    //通过取地址符&,获取 a 的地址,赋值给指针变量
    pa = &a;
    //通过间接寻址符,获取指针指向的内容
    printf("%d", *pa);
    

    (3)“&”和“*”的结合方向

    “&”和“*”都是右结合的。假设有变量 x = 10,则*&x 的含义是,先获取变量 x 的地址,再获取地址中的内容。因为“&”和“*”互为逆运算,所以 x = *&x。

    接下来做个小练习,输入 x、y 两个整数,然后将其中的值大的赋值给 x,小的赋值给 y。即:假设输入 x = 8,y = 9。就将 9 赋值给 x,8 赋值给 y。

    void main(){
    	//声明两个普通变量
    	int x, y;
    	//声明两个指针变量
    	int *px, *py;
    	//声明一个临时变量,用于交换
    	int t;
    	//输入两个值,赋值给 x、y
    	scanf("%d", &x);
    	scanf("%d", &y);
    	//给指针变量 px、py 赋初值(关联变量 x、y)
    	px = &x;
    	py = &y;
    	//利用指针来对比 x、y 的值,如果 x 的值比 y 的值小,就交换
    	if(*px < *py){
    		//交换步骤,其中*px == x、*py == y
    		t = *px;
    		*px = *py;
    		*py = t;
    	}
    	printf("x =  %d, y = %d", *px, *py);
    }
    
    输入:23 45
    输出结果为:x = 45, y = 23
    

    2.2、指针变量的初始化

    指针变量与其它变量一样,在定义时可以赋值,即初始化。也可以赋值“NULL”或“0”,如果赋值“0”,此时的“0”含义并不是数字“0”,而是 NULL 的字符码值。

    //利用取地址获取 x 的地址,在指针变量 px 定义时,赋值给 px
    int x;
    int *px = &x;
    //定义指针变量,分别赋值“NULL”和“0”
    int *p1= NULL, *p2 = 0;
    

    2.3、指针运算

    (1)赋值运算

    指针变量可以互相赋值,也可以赋值某个变量的地址,或者赋值一个具体的地址

    int *px, *py, *pz, x = 10;
    //赋予某个变量的地址
    px = &x;
    //相互赋值
    py = px;
    //赋值具体的地址
    pz = 4000;
    

    (2)指针与整数的加减运算

    1. 指针变量的自增自减运算。指针加 1 或减 1 运算,表示指针向前或向后移动一个单元(不同类型的指针,单元长度不同)。这个在数组中非常常用。
    2. 指针变量加上或减去一个整形数。和第一条类似,具体加几就是向前移动几个单元,减几就是向后移动几个单元。
    //定义三个变量,假设它们地址为连续的,分别为 4000、4004、4008
    int x, y, z;
    
    //定义一个指针,指向 x
    int *px = &x;
    
    //利用指针变量 px 加减整数,分别输出 x、y、z
    printf("x = %d", *px);		//因为 px 指向 x,所以*px = x
    
    //px + 1,表示,向前移动一个单元(从 4000 到 4004)
    //这里要先(px + 1),再*(px + 1)获取内容,因为单目运算符“*”优先级高于双目运算符“+”
    printf("y = %d", *(px + 1));		
    printf("z = %d", *(px + 2));
    

    (3)关系运算

    假设有指针变量 px、py。

    1. px > py 表示 px 指向的存储地址是否大于 py 指向的地址
    2. px == py 表示 px 和 py 是否指向同一个存储单元
    3. px == 0 和 px != 0 表示 px 是否为空指针
    //定义一个数组,数组中相邻元素地址间隔一个单元
    int num[2] = {1, 3};
    
    //将数组中第一个元素地址和第二个元素的地址赋值给 px、py
    int *px = &num[0], *py = &num[1];
    int *pz = &num[0];
    int *pn;
    
    //则 py > px
    if(py > px){
    	printf("py 指向的存储地址大于 px 所指向的存储地址");
    }
    
    //pz 和 px 都指向 num[0]
    if(pz == px){
    	printf("px 和 pz 指向同一个地址");
    }
    
    //pn 没有初始化
    if(pn == NULL || pn == 0){
    	printf("pn 是一个空指针");
    }
    

    三、指针与数组

    之前我们可以通过下标访问数组元素,学习了指针之后,我们可以通过指针访问数组的元素。在数组中,数组名即为该数组的首地址,结合上面指针和整数的加减,我们就可以实现指针访问数组元素。

    3.1、指向数组的指针

    如以下语句:

    int nums[10], *p;
    

    上面语句定义了一个数组 nums,在定义时分配了 10 个连续的int 内存空间。而一个数组的首地址即为数组名nums,或者第一个元素的首地址也是数组的首地址。那么有两种方式让指针变量 p 指向数组 nums:

    //数组名即为数组的首地址
    p = nums;
    //数组第一个元素的地址也是数组的首地址
    p = &nums[0];
    

    上面两句是等价的。
    如下几个操作,用指针操作数组:

    1. *p = 1,此操作为赋值操作,即将指针指向的存储空间赋值为 1。此时 p 指向数组 nums 的第一个元素,则此操作将 nums 第一个元素赋值为 0,即 nums[0] = 1。
    2. p + 1,此操作为指针加整数操作,即向前移动一个单元。此时 p + 1 指向 nums[0]的下一个元素,即 nums[1]。通过p + 整数可以移动到想要操作的元素(此整数可以为负数)。
    3. 如上面,p(p + 0)指向 nums[0]、p + 1 指向 nums[1]、、、类推可得,p+i 指向 nums[i],由此可以准确操作指定位置的元素。
    4. 在 p + 整数的操作要考虑边界的问题,如一个数组长度为 2,p+3 的意义对于数组操作来说没有意义。

    下面写一段代码,用指针访问数组的元素:

    //定义一个整形数组,并初始化
    int nums[5] = {4, 5, 3, 2, 7};
    
    //定义一个指针变量 p,将数组 nums 的首地址赋值给 p,也可以用p = &nums[0]赋值
    int *p = nums, i;			//i 作为循环变量
    
    //p 指向数组第一个元素(数组首地址),我们可以直接用间接寻址符,获取第一个元素的内容
    printf("nums[0] = %d\n", *p);			//输出结果为 nums[0] = 4
    
    //我们可以通过“p + 整数”来移动指针,要先移动地址,所以 p + 1 要扩起来
    printf("nums[1] = %d\n", *(p + 1));		//输出结果为 nums[1] = 5
    
    //由上面推导出*(p + i) = nums[i],所以我们可以通过 for 循环变量元素
    for(i = 0; i < 5; i++){
    	printf("nums[%d] = %d", i, *(p + i));
    }
    

    注:数组名不等价于指针变量,指针变量可以进行 p++和&操作,而这些操作对于数组名是非法的。数组名在编译时是确定的,在程序运行期间算一个常量。

    3.2、字符指针与字符数组

    在 C 语言中本身没有提供字符串数据类型,但是可以通过字符数组和字符指针的方式存储字符串。

    (1)字符数组方式

    这个在前面应该学习过,这里就不赘述了。

    char word[] = "zack";
    printf("%s", word);
    

    (2)字符指针方式

    指针方式操作字符串和数组操作字符串类似,可以把定义的指针看做是字符数组的数组名。在内存中存储大致如下,这里为了方便换了个字符串:在这里插入图片描述

    //除了定义一个字符数组外,还可以直接定义一个字符指针存储字符串
    char *sentence = "Do not go gentle into that good night!";
    
    //此时可以做字符串的操作
    //输出
    printf("%s", sentence);
    
    //通过下标取字符
    printf("%c", sentence[0]);
    
    //获取字符串长度,其中 strlen 是 string.h 库中的方法
    printf("%d", strlen(sentence));
    

    注:字符指针方式区别于字符数组方式,字符数组不能通过数组名自增操作,但是字符指针是指针,可以自增操作。自增自减少会实现什么效果大家可以自己尝试运行一下

    下面做个小练习,利用字符指针将字符数组 sentence 中的内容复制到字符数组 word 中:

    //定义字符数组 sentence 和 word,给 sentence 赋初值
    char sentence[] = "Do not go gentle into that good night!", word[100];
    
    //定义字符指针,指向 word
    char *ch = word;
    int i;
    
    //循环赋值
    for(i = 0; sentence[i] != '\0'; i++){
    	*(ch + i) = sentence[i];
    }
    
    //在当 i 等于 sentence 的长度(sentence 的长度不包含'\0')时,
    //i 继续自增,此时判断 sentence[0] != '\0'不符合,跳出循环,则 i 比 sentence 长度大 1
    *(ch + i) = '\0';
    
    //输出字符串,因为 ch 指向 word,所以输出结果是一样的
    printf("ch = %s, word = %s", ch, word);
    

    注:指针变量必须初始化一个有效值才能使用

    3.3、多级指针及指针数组

    (1)多级指针

    指针变量作为一个变量也有自己的存储地址,而指向指针变量的存储地址就被称为指针的指针,即二级指针。依次叠加,就形成了多级指针。我们先看看二级指针,它们关系如下:指针变量 p 指向变量 x,二级指针变量指向指针变量 p
    其中 p 为一级指针,pp 为二级指针。二级指针定义形式如下:

    数据类型 **二级指针名;
    

    和指针变量的定义类似,由于*是右结合的,所以*pp 相当于*(*p)。在本次定义中,二级指针的变量名为 pp,而不是**p。多级指针的定义就是定义时使用多个“*”号。下面用一个小程序给大家举例:

    //定义普通变量和指针变量
    int *pi, i = 10;
    //定义二级指针变量
    int **ppi;
    
    //给指针变量赋初值
    pi = &i;
    
    //给二级指针变量赋初值
    ppi = &pi;
    
    //我们可以直接用二级指针做普通指针的操作
    //获取 i 的内容
    printf("i = %d", **ppi);
    //获取 i 的地址
    printf("i 的地址为%d", *ppi);
    

    注:在初始化二级指针 ppi 时,不能直接 ppi = &&i,因为&i 获取的是一个具体的数值,而具体数字是没有指针的。

    (2)指针数组

    指针变量和普通变量一样,也能组成数组,指针数组的具体定义如下:

    数据类型 *数组名[指针数组长度];
    

    下面举一个简单的例子熟悉指针数组:

    //定义一个数组
    int nums[5] = {2, 3, 4, 5, 2}, i;
    
    //定义一个指针数组
    int *p[5];
    
    //定义一个二级指针
    int **pp;
    
    //循环给指针数组赋值
    for(i = 0; i < 5; i++){
    	p[i] = &nums[i];
    }
    
    //将指针数组的首地址赋值给 pp,数组 p 的数组名作为 p 的首地址,也作为 p 中第一个元素的地址。
    //数组存放的内容为普通变量,则数组名为变量的指针;数组存放的内容为指针,则数组名为指针的指针。
    pp = p;
    
    //利用二级指针 pp 输出数组元素
    for(i = 0; i < 5; i++){
    	//pp == &p[0] == &&nums[0],nums[0] == *p[0] == **pp
    	printf("%d", **pp);
    	
    	//指针变量+整数的操作,即移动指针至下一个单元
    	pp++;
    }
    

    3.4、指针与多维数组

    讲多维数组是个麻烦的事,因为多维数组和二维数组没有本质的区别,但是复杂度倒是高了许多。这里我主要还是用二维数组来举例,但是还是会给大家分析多维数组和指针的关系。

    (1)多维数组的地址

    先用一个简单的数组来举例:

    int nums[2][2] = {
    	{1, 2},
    	{2, 3}
    };
    

    我们可以从两个维度来分析:

    1. 先是第一个维度,将数组当成一种数据类型 x,那么二维数组就可以当成一个元素为 x 的一维数组。
    2. 如上面的例子,将数组看成数据类型 x,那么 nums 就有两个元素。nums[0]和 nums[1]。
    3. 我们取 nums[0]分析。将 nums[0]看做一个整体,作为一个名称可以用 x1 替换。则 x1[0]就是 nums[0][0],其值为 1。
      在这里插入图片描述

    我们知道数组名即为数组首地址,上面的二维数组有两个维度。首先我们把按照上面 1 来理解,那么 nums 就是一个数组,则nums 就作为这个数组的首地址。第二个维度还是取 nums[0],我们把 nums[0]作为一个名称,其中有两个元素。我们可以尝试以下语句:

    printf("%d", nums[0]);
    

    此语句的输出结果为一个指针,在实验过后,发现就是 nums[0][0]的地址。即数组第一个元素的地址。

    如果再多一个维度,我们可以把二维数组看做一种数据类型 y,而三维数组就是一个变量为 y 的一维数组。而数组的地址我们要先确定是在哪个维度,再将数组某些维度看成一个整体,作为名称,此名称就是该维度的地址(这里有些绕)。

    例:

    //假设已初始化,二维数组数据类型设为 x,一维数组数据类型设为 y
    int nums[2][2][2];
    
    //此数组首地址为该数组名称
    printf("此数组首地址为%d", nums);
    
    //此数组可以看做存储了两个 x 类型元素的一维数组,则 nums[0] = x1 的地址为
    printf("第二个维度的首地址为%d", nums[0]);
    
    //而 x1 可以看做存储了两个 y 类型元素的一维数组,则 y1 = x1[0] = nums[0][0]
    printf("第三个维度的首地址为%d", nums[0][0]);
    
    

    三维数组实际存储形式如下:
    在这里插入图片描述
    实际存储内容的为最内层维度,且为连续的。对于 a 来说,其个跨度为 4 个单元;对 a[0]来说,其跨度为 2 个单元;对 a[0][0]来说,跨度为一个单元。有上面还可以得出:

    a == a[0] == a[0][0] == &a[0][0][0];
    

    上面的等式只是数值上相等,性质不同。

    (2)多维数组的指针

    在学习指针与数组的时候,我们可以如下表示一个数组:

    int nums[5] = {2, 4, 5, 6, 7};
    int *p = nums;
    

    在前面讲指针数组时,所有指针数组元素都指向一个数字,那么我们现在可以尝试用指针数组的每个元素指向一个数组:

    //定义一个二维数组
    int nums[2][2] = {
    	{1, 2},
    	{2, 3}
    };
    
    //此时 nums[0]、和 nums[1]各为一个数组
    int *p[2] = {nums[0], nums[1]};
    
    //我们可以用指针数组 p 操作一个二维数组
    
    //p 为数组 p 的首地址,p[0] = nums[0] = *p,**p = nums[0][0]
    printf("nums[0][0] = %d", **p);
    
    //指针 + 整数形式,p+1 移动到 nums 的地址,*(p +1) = nums[1],则**(p + 1) = nums[1][0]
    printf("nums[1][0] = %d", **(p + 1));
    
    //先*p = nums[0],再*p + 1 = &nums[0][1],最后获取内容*(*p + 1)即为 nums[0][1]
    printf("nums[0][1] = %d", *(*p + 1));
    

    这里可能不能理解为什么*p + 1 = &nums[0][1],而不是 nums[1]。*p 获得的是一个一维数组,而 int 数组 + 1 的跨度只有 4 个字节,也就是一个单元。前面 p 是一维数组的指针,其跨度为一个数组。所以*p + 1 = &nums[0][1],而 p + 1 = nums[1]。

    四、指针与函数

    前面学习函数学到,函数参数可以为 int、char、float 等,但是在操作时,这些参数只作为形参,所有操作都只在函数体内有效(除对指针的操作外),那么今天来学习一下指针作为函数参数。

    4.1、函数参数为指针

    我们直接做一个练习,定义一个函数,用来交换两个变量的内容。

    void swap(int *x, int *y);
    void main(){
    	int x = 20, y = 10;
    	swap(&x, &y);
    	printf("x = %d, y = %d", x ,y);
    }
    void swap(int *x, int *y){
    	int t;
    	t = *x;
    	*x = *y;
    	*y = t;
    }
    

    代码非常简单,我也就不细讲了。这里传入的参数为指针,所以调用 swap 方法后 x,y 的内容发生了交换。如果直接传入 x,y,那么交换只在 swap 中有效,在 main 中并没有交换。

    4.2、函数的返回值为指针

    返回值为指针的函数声明如下:

    数据类型 *函数名(参数列表){
    	函数体
    }
    //例如:
    int s;
    int *sum(int x, int y){
    	s = x + y;
    	return &s;
    }
    

    在函数调用前要声明需要对函数声明(有点编译器不需要)

    int s;
    void mian(){
    	int *r = sum(10, 9);
    	printf("10 + 9 + %d", *r);
    }
    int *sum(int x, int y){
    	s = x + y;
    	return &s;
    }
    

    除了上面的操作,更实用的是返回一个指向数组的指针,这样就实现了返回值为数组。

    4.3、指向函数的指针

    C 语言中,函数不能嵌套定义,也不能将函数作为参数传递。但是函数有个特性,即函数名为该函数的入口地址。我们可以定义一个指针指向该地址,将指针作为参数传递。

    函数指针定义如下:

    数据类型 (*函数指针名)();
    

    函数指针在进行“*”操作时,可以理解为执行该函数。函数指针不同与数据指针,不能进行+整数操作。

    下面举个例子,来使用函数指针:

    #include <string.h>
    /**
    *	定义一个方法,传入两个字符串和一个函数指针 p,用 p 对两个字符串进行操作
    */
    void check(char *x, char *y, int (*p)());
    void main(){
    	//string.h 库中的函数,使用之前需要声明该函数。字符串比较函数
    	int strcmp();
    	char x[] = "Zack";
    	char y[] = "Rudy";
    	
    	//定义一个函数指针
    	int (*p)() = strcmp;
    
    	check(x, y, p);
    }
    void check(char *x, char *y, int (*p)()){
    	if(!(*p)(x, y)){
    		printf("相等");
    	}else{
    		printf("不相等");
    	}
    }
    

    利用函数指针调用方法具体操作如下:

    (*p)(x, y);
    

    指针除了这些地方,还在结构体中用处巨大。今天就先讲到这里~·

    展开全文
  • 指针:针对对象类型,对象在堆中分配...使用任何的对象数据时,都要进行空指针判断。 通用的方式有三种: (1)null显式判断 (2)Objects.isNull(Object)隐式判断 (3)CollectionUtils工具判断指针和空数据

    1 简介

    空指针:针对对象类型,对象在堆中分配“房子”。空指针(null)的对象没有分配到“房子”,所以,无法使用该对象。
    使用任何的对象数据时,都要进行空指针判断。
    通用的方式有三种:

    1. null显式判断
    2. Objects.isNull(Object)隐式判断
    3. CollectionUtils工具判断空指针和空数据

    2 引用类型

    2.1 null直接显式判断空指针

    /**
         * 引用类型:直接使用null判断空指针
         */
        @Test
        public void nullRawTest() {
            String var1 = null;
            if (null == var1) {
                logger.info(">>>>>>>>>>var1 is null");
            } else {
                logger.info(">>>>>>>>>>var1 is:{}", var1);
            }
        }
    

    2.2 Objects.isNull隐式判断空指针

    /**
         * 引用类型:使用Objects工具判断空指针
         */
        @Test
        public void nullUnderObjectsTest() {
            String var1 = null;
            if (Objects.isNull(var1)) {
                logger.info(">>>>>>>>>>var1 is null");
            } else {
                logger.info(">>>>>>>>>>var1 is:{}", var1);
            }
        }
    

    3 集合类型

    3.1 null直接显式判断空指针

    /**
         * 集合类型:直接使用null判断空指针
         */
        @Test
        public void nullCollectionUnderRawTest() {
            List<String> list1 = null;
            if (null == list1) {
                logger.info(">>>>>>>>>>lsit1 is null");
            } else if (list1.isEmpty()) {
                logger.info(">>>>>>>>>>list1 is empty");
            } else {
                logger.info(">>>>>>>>>>list1 is:{}", list1);
            }
        }
    

    3.2 Objects.isNull隐式判断空指针

        /**
         * 集合类型:使用Objects判断空指针
         */
        @Test
        public void nullCollectionUnderObjectsTest() {
            List<String> list1 = null;
            if (Objects.isNull(list1)) {
                logger.info(">>>>>>>>>>lsit1 is null");
            } else if (list1.isEmpty()) {
                logger.info(">>>>>>>>>>list1 is empty");
            } else {
                logger.info(">>>>>>>>>>list1 is:{}", list1);
            }
        }
    

    3.3 CollectionUtils.isEmpty工具判断空指针和空

    CollectionUtils判断

    3.3.1 引入依赖

    Apache通用集合工具:4.4版本。

    <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-collections4</artifactId>
        <version>4.4</version>
    </dependency>
    

    3.3.2 空指针

    /**
         * 集合类型:使用CollectionUtils判断空指针和空数据
         */
        @Test
        public void nullUnderCollectionUtilsTest() {
            List<String> list1 = null;
            if (CollectionUtils.isEmpty(list1)) {
                logger.info(">>>>>>>>>>var1 is null or empty");
            } else {
                logger.info(">>>>>>>>>>var1 is:{}", list1);
            }
        }
    

    3.3.3 空数据

    /**
         * 集合类型:使用CollectionUtils判断空指针和空数据
         */
        @Test
        public void emptyUnderCollectionUtilsTest() {
            List<String> list1 = Collections.emptyList();
            if (CollectionUtils.isEmpty(list1)) {
                logger.info(">>>>>>>>>>var1 is null or empty");
            } else {
                logger.info(">>>>>>>>>>var1 is:{}", list1);
            }
        }
    

    3 小结

    序号方法描述
    1null判断通用方法。所有对象均可以使用该方法判断空指针。
    2Objects.isNull(Object)判断通用方法。所有对象均可以使用该方法判断空指针。
    3CollectionUtils.isEmpty(Collection)判断Collection集合类型的数据判断空指针。

    4 完整样例

    package com.monkey.java_study.functiontest;
    
    import org.apache.commons.collections4.CollectionUtils;
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    import org.junit.Test;
    
    import java.util.*;
    
    /**
     * 空指针判断测试.
     *
     * @author xindaqi
     * @date 2021-12-16 9:55
     */
    public class NullPointerTest {
    
        private static final Logger logger = LogManager.getLogger(NullPointerTest.class);
    
        private static final String TEST_VALUE = "test";
    
        /**
         * 引用类型:直接使用null判断空指针
         */
        @Test
        public void nullRawTest() {
            String var1 = null;
            if (null == var1) {
                logger.info(">>>>>>>>>>var1 is null");
            } else {
                logger.info(">>>>>>>>>>var1 is:{}", var1);
            }
        }
    
        /**
         * 引用类型:使用Objects工具判断空指针
         */
        @Test
        public void nullUnderObjectsTest() {
            String var1 = null;
            if (Objects.isNull(var1)) {
                logger.info(">>>>>>>>>>var1 is null");
            } else {
                logger.info(">>>>>>>>>>var1 is:{}", var1);
            }
        }
    
        /**
         * 集合类型:直接使用null判断空指针
         */
        @Test
        public void nullCollectionUnderRawTest() {
            List<String> list1 = null;
            if (null == list1) {
                logger.info(">>>>>>>>>>list1 is null");
            } else if (list1.isEmpty()) {
                logger.info(">>>>>>>>>>list1 is empty");
            } else {
                logger.info(">>>>>>>>>>list1 is:{}", list1);
            }
        }
    
        /**
         * 集合类型:使用Objects判断空指针
         */
        @Test
        public void nullCollectionUnderObjectsTest() {
            List<String> list1 = null;
            if (Objects.isNull(list1)) {
                logger.info(">>>>>>>>>>list1 is null");
            } else if (list1.isEmpty()) {
                logger.info(">>>>>>>>>>list1 is empty");
            } else {
                logger.info(">>>>>>>>>>list1 is:{}", list1);
            }
        }
    
        /**
         * 集合类型:使用CollectionUtils判断空指针和空数据
         */
        @Test
        public void nullUnderCollectionUtilsTest() {
            List<String> list1 = null;
            if (CollectionUtils.isEmpty(list1)) {
                logger.info(">>>>>>>>>>var1 is null or empty");
            } else {
                logger.info(">>>>>>>>>>var1 is:{}", list1);
            }
        }
    
        /**
         * 集合类型:使用CollectionUtils判断空指针和空数据
         */
        @Test
        public void emptyUnderCollectionUtilsTest() {
            List<String> list1 = Collections.emptyList();
            if (CollectionUtils.isEmpty(list1)) {
                logger.info(">>>>>>>>>>var1 is null or empty");
            } else {
                logger.info(">>>>>>>>>>var1 is:{}", list1);
            }
        }
    }
    
    展开全文
  • 数组指针指针数组区别判断

    千次阅读 多人点赞 2022-03-24 18:33:59
    对于c语言的初学者来说,往往容易将数组指针指针数组混淆,本文将对二者概念以及其用法进行详细解释。 1.&数组名 vs 数组名 &arr和arr有什么区别呢,&arr+1和arr+1又有什么区别呢,接下来请看下图。...

    目录

    前言

    1.&数组名 vs 数组名

    2.指针数组

    2.1指针数组的使用

    3.数组指针

    3.1数组指针的使用

    结语:


    前言

    对于c语言的初学者来说,往往容易将数组指针和指针数组混淆,本文将对二者概念以及其用法进行详细解释。

    1.&数组名 vs 数组名

    &arr和arr有什么区别呢,&arr+1和arr+1又有什么区别呢,接下来请看下图。

    由上图很容易看出,arr和&arr的值是一样的,但是所表示的意义是不一样的。

    实际上:&arr表示的是整个数组的地址,arr表示的是该数组首元素的地址。

    虽然二者的值相等,但是在arr+1与&arr+1上显示出的值是不一样的。arr+1与arr表示出的值相差4字节,即一个整型空间;&arr+1与&arr表示出的值相差40个字节,即10个整型空间;所以arr+1跳过的是该数组的一个整型元素,而&arr+1跳过的是整个数组的10个元素。

    补充:

    在数组名的使用中,有两种数组名的使用情况表示取出整个数组,其他情况都表示取出首元素的地址:

    1.sizeof(arr)表示的是计算整个数组的大小,sizeof内部单独放一个数组,数组名表示整个数组。

    2.&数组名,取出的是整个数组的地址,&数组名,数组名表示整个数组。

    2.指针数组

    指针数组即是存放指针的数组,本质上是数组,该数组存放的元素是指针。

    int arr[]是存放整型的数组;char arr[]是存放字符的数组;float arr[]是存放浮点型的数组;所以arr[]前的类型声明了该数组的类型,所以int*arr[]表示是存放整型指针的数组;char* arr[]是存放字符型指针的数组。

    2.1指针数组的使用

    如上图,该指针数组存放的是a b c整型变量的地址。

    3.数组指针

    数组指针本质是指针,如int*p表示的是指向整型数据的指针;float*p表示的是指向浮点型数据的指针,所以数组指针是指向数组的指针。

    数组指针的的书写:int (*p)[10],p和*先结合说明p是一个指针变量,然后指向的是一个大小为10的整型数组,所以叫数组指针。注意书写是()不可遗漏,[]的优先级大于(),必须保证*和p

    先结合。

    3.1数组指针的使用

    数组指针在二维数组中的使用例子如下。

    //打印二维数组
    #include <stdio.h>
    void print(int (*p)[5], int row, int col)
    {
    	int i = 0;
    	for (i = 0; i < row; i++)
    	{
    		int j = 0;
    		for (j = 0; j < col; j++)
    		{
    			printf("%d ", *(*(p + i) + j));
    				//p+i指向的是第i行的地址
    				// *(p+i)是取到了第i行的地址,
    				// *(p+i)+j是指向第i行第j列的地址
    				// *(*(p+i)+j)取出的是第i行第j列的元素			
    		
    		}
    		printf("\n");
    	}
    
    }
    int main()
    {
    	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
    	print(arr, 3, 5);
    	//数组名arr,表示首元素的地址。
    	//对于二维数组的首元素是第一行。
    	//所以传递的是第一行的地址,即一维数组的地址。
    	//可以用数组指针接受
    	return 0;
    }
    

    代码运行结果如上。

    结语:

    数组指针和指针数组的解释到此完结,初学者读了此篇应该有所收获。

     

     

    展开全文
  • C++判断指针是否被delete

    千次阅读 2022-04-15 23:41:08
    重载new/delete操作符,用静态数据结构记录被删除的指针,用类成员静态函数判断指针是否被删除。 实现代码 #include <set> #include<stdlib.h> static std::set<void *> deleted_p;//记录已经被...
  • 数据结构判断

    千次阅读 多人点赞 2021-05-20 21:47:14
    1.将N个数据按照从小到大顺序组织存放在一个单向链表中。如果采用二分查找,那么查找的平均时间复杂度是O(logN)。 F 解析: 二分查找的平均复杂度是O(logN)没有错,一看到这个就跳坑了。然后知道陷阱来了!按顺序...
  • Python中DataFrame使用判断语句选取、过滤满足判断条件的行- 通过逻辑指针进行数据切片 使用逻辑判断语句:df1[df['col']>= 2] #逻辑条件 使用具体的例子看: 1.创建dataframe对象df1 df1=pd.DataFrame(np.a...
  • Java 数据类型及其判断

    千次阅读 2021-03-05 17:34:31
    一、Java中的数据类型,可分为两类:1.基本数据类型,也称原始数据类型:byte、short、char、int、long、float、double、boolean它们之间的比较,应该用双等号(==)比较的是它们的值。2.引用数据类型:JAVA当中所有的...
  • 指针就是指向变量的地址 在这里插入代码片 指针常量 int * const p =&a; 特点:指针的指向不可以修改,指针指向的内存的值可以修改 举例: *p = 20; p=&b; 常量指针 int a = 10; int b = 10; const int *p...
  • 使用指针判断字符串长度

    千次阅读 2019-06-11 11:02:32
    要求使用指针的方法遍历该字符串,并统计该字符串的长度。不允许使用strlen()函数。 输入 输入一个字符串,不多于999个字符,以回车结束。 输出 输出字符串的长度。 输入示例 apple 输出示例 5 数据范围 输入为字符...
  • C语言指针**p是什么意思

    千次阅读 2021-05-23 12:48:11
    指针怎么理解1、指针的概念指针是一个特殊的变量,它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容:指针的类型,指针所指向的类型,指针的值或者叫指针所指向的内存区,...
  • 要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,...
  • 指针详解

    千次阅读 多人点赞 2021-04-05 19:25:16
    在时间或空间条件有限的情况下使用单向遍历需要消耗大量的时间或者根本无法解决问题,这时候就需要我们使用双指针,通过指针的碰撞判断是否达到条件,从而解决问题。 双指针分为快慢指针和左右指针,左右指针通常在...
  • 这几天在基础不好的情况下开始用c++强行写cocos2d,碰到了无数堆对象栈对象、空指针野指针的问题。 今天想到了一个较为简单的判断指针是否已被释放的方法。
  • js判断数据类型(全)

    千次阅读 2022-04-11 08:05:30
    js基本数据类型 基本数据类型: String、Number、Boolean、Undefined未定义、null空、symbol表示独一无二...null:null值表示一个空对象指针,typeof null 结果是object。 symbol(符号):是原始值,且实例是唯一、不
  • c语言指针用法详解,通俗易懂超详细!

    万次阅读 多人点赞 2021-07-18 00:10:30
    文章转自:无际单片机大家好,我是无际。今天给大家来讲解一下指针。我会由浅到深,最后结合实际应用讲解,让大家学会指针的同时,知道大佬们都用指针来干嘛!长文预警!全文大约5200多字,学指针看...
  • C++中判断指针是否为空有3中方法(NULL, 0, nullptr),我们接下来分别对他们进行比较。 1. NULL NULL是C语言的内容,在C语言中,NULL的定义为:#define NULL ((void *)0)。 因此,我们写 int* p = NUL...
  • 数据结构】链表中的 指针地址

    千次阅读 多人点赞 2018-10-17 18:55:04
    数据结构中跳过集合,直接开始线性结构 线性结构中单链表的操作涉及到给一个变量赋值地址,所以涉及到了指针 通过指针里的地址很方便找到节点 但指针这里绕了我很长时间,不论学了多少遍也不敢说把指针学会了 地址...
  • 版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载...要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算...
  • C++判断指针的类型

    千次阅读 2015-06-29 10:40:07
    #include using namespace std; class A { public: A() { a = 0; } int a; }; class B { public: B() { a = 0; b = 0; } int a, b; }; int main() { A clsA;... A *pclsA = new A
  • C语言之指针,便于理解

    千次阅读 2021-05-25 06:40:01
    地址变量(指针变量)存储地址值。1、定义的格式:类型名 *指针变量名;如:int a,b,*p1,*p2;float x,y,*p3,*p4;chars,*p5,*p6;注:(1)定义变量(普通变量、指针变量)都必须在前面有类型名。(2)在定义指针...
  • skb结构体中的长度和数据指针 len: 线性区和分片区域的总长度 data_len:分片区域frag page中的数据长度 len-data_len: 当前协议层中的线性区长度 head:线性区的起始地址 data:数据的起始地址 tail:数据的结束...
  • 文章目录【C】C语言判断字符串是否是int型正整数前言一、代码二、结果 【C】C语言判断字符串是否是int型正整数 前言 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;此程序功能...
  • C++智能指针详解

    千次阅读 多人点赞 2021-07-23 10:44:22
    new:在动态内存中为对象分配一块空间并返回一个指向该对象的指针; delete:指向一个动态独享的指针,销毁对象,并释放与之关联的内存。 动态内存管理经常会出现两种问题: (1)一种是忘记释放内存,会造成内存泄漏...
  • 要点: 头指针表明了链表的起点,可以唯一确定一个单链表。...头结点的数据域可以不储存任何数据。 如下图: (转自:https://blog.csdn.net/qq_35514178/article/details/102636001?utm_medium=distribu
  • 兜兜绕绕两三天终于到了重要的地方了,当初想到要学数据结构的时候,以及后面了解到数据结构的语言无关性之后,心里不免还是有个疑问:Python也没有指针啊,怎么样像C语言那样通过指针来实现更高级的数据结构呢?...
  • 不了解的对指针的理解就停留在“指针就是变量的地址”这句话,会比较害怕使用指针,特别是各种高级操作。 而了解内存模型的则可以把指针用得炉火纯青,各种 byte 随意操作,让人直呼 666。 一、内存本质 编程的本质...
  • 指针比较大小?。?

    千次阅读 2020-06-30 20:15:12
    指针存的是地址,直接比较当然是地址大小啦.q=p+1后,q指向p指向的元素后面的地址zhi,所以q大于daop,比如p存的数据地址1000,+1后就是1004,存入q,显然q大于p.指针也是变量啊,只是存的是地址而已,很多人绕不过这个弯...
  • 指针指针变量的区别(C语言)

    千次阅读 2022-03-26 16:48:54
    提示:本章主要谈及个人对C语言指针指针变量的理解 文章目录前言一、指针是什么?二、指针变量是什么?三、知识拓展总结 前言 指针是C语言中的一个很重要的concept,掌握指针的应用,可以使程序更加简洁、紧凑和...
  • 在其他语言中比如(Java,c#)可以直接判断类的对象是否是null来判断类的对象是否为空,但是在c++中由于指针的存在,不能直接判断类的对象,而应该判断指向对象的指针是否为空。  C++语言中,对象没有空和不空的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 544,271
精华内容 217,708
热门标签
关键字:

判断地址是指针还是数据