assert AND const

最新推荐文章于 2024-08-22 17:12:21 发布

原创最新推荐文章于 2024-08-22 17:12:21 发布 · 269 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

C指针专栏收录该内容

10 篇文章

订阅专栏

本文详细介绍了C语言中的断言(assert)用法及其在程序中的作用，包括如何预防程序运行时错误的发生。此外，还深入探讨了const关键字的使用技巧，通过实例解释了不同类型const变量的特点及应用场景。

assert：

断言：断定表达式的结果一定为真，如果为真什么都不做，如果为假程序崩溃（debug）

断言的使用必须包含的头文件：#include <assert.h>

举例：

1、计算字符串的有效长度，不包含'\0'

#include <stdio.h>
#include <assert.h>
#include <string.h>

int Mystrlen(const char *str)
{
assert(str != NULL);
if(str == NULL)
{
return -1;
}
int i = 0;
while(*str != '\0')//for(i=0;str[i]!='\0';i++)
{
i++;
str++;
}
return i;
}
int main()
{
char str1[10] = "abcd";
printf("%d\n",Mystrlen(str1));
printf("%d\n",Mystrlen(""));
return 0;
}

2、除法

#include <stdio.h>
#include <assert.h>
#include <string.h>
int Div(int a,int b)
{
assert(b != 0);
return a / b;
}

int main()
{
printf("%d\n",Div(10,5));
printf("%d\n",Div(10,3));
printf("%d\n",Div(10,50));

printf("%d\n",Div(10,0));

return 0;

}const：定义常变量,不能写，只读
a、数据类型对于const而言是透明的
b、const用于封锁直接修饰的内容，将该内容变为只读

c、权限只能同等传递或者缩小传递

分类:

1、

<1>const 类型变量；
<2>类型 const 变量： //<1>、<2>相同

2、

<1>const 类型 * 变量;
<2>类型 const * 变量;

<3>类型 * const 变量; //<1>、<2>相同，与<3>不同，即分为指针左、指针右两种

举例：

int main()
{
int a = 10; // a为普通变量，可进行的操作：读，写
int b = 20; // b为普通变量，可进行的操作：读，写
const int ca = 10; //ca为const定义的整型变量，可进行的操作：读
const int cb = 20; //cb为const定义的整型变量，可进行的操作：读
int *p = &a; //定义整型指针p，并将a的地址赋值给指针p；
//p = &ca; //该操作将const定义的整型变量ca地址赋值给指针p，因ca只能进行读操作，不能进行写操作，将ca地址赋值给指针p后，指针p即可完成赋值操作，因此该操作错误
const int *cp1 = &a; //重新定义一个由const定义的整型变量cp1；并将a的地址赋值给cp1，因变量a为普通整形变量，可以进行读、写操作，将a的地址赋值给指针cp1后，指针cp1可进行读操作，因此该操作正确
cp1 = &b; //将b的地址赋值给cp1，因变量b为普通整形变量，可以进行读、写操作，将b的地址赋值给指针cp1后，指针cp1可进行读操作，因此该操作正确
cp1 = &ca; //将ca的地址赋值给cp1，因变量ca与cp1为const定义同类型变量，因此可以进行读、写操作，将ca的地址赋值给指针cp1后，指针cp1可进行读操作，因此该操作正确

const int *cp2 = &ca; //重新定义一个由const定义的整型变量cp2；将ca的地址赋值给cp2，因变量ca与cp2为const定义同类型变量，因此可以进行读、写操作，将ca的地址赋值给指针cp2后，指针cp2可进行读操作，因此该操作正确
int *const cp3 = &a; //重新定义一个由const定义的整型变量cp3；并将a的地址赋值给cp3，因变量a为普通整形变量，可以进行读、写操作，将a的地址赋值给指针cp3后，指针cp3可进行读操作，因此该操作正确
//int *const cp4 = &ca; //重新定义一个由const定义的整型变量cp4；将ca的地址赋值给cp4，因变量ca与cp4为不同类型的const变量，不可进行赋值等操作，因此该操作错误
const int *const cp5 = &a; //重新定义一个由const定义的整型变量cp5；将a的地址赋值给cp5，因变量a与cp5为const定义同类型变量，因此可以进行读、写操作，将a的地址赋值给指针cp5后，指针cp5可进行读操作，因此该操作正确
const int *const cp6 = &ca; //重新定义一个由const定义的整型变量cp6；将ca的地址赋值给cp6，因变量ca与cp6为const定义同类型变量，因此可以进行读、写操作，将ca的地址赋值给指针cp6后，指针cp6可进行读操作，因此该操作正确

return 0;

}

注意：const直接修饰的变量不可修改，

练习：
int main()
{
int a = 10;
int b;
a = 20;
b = a;
const int ca = 100; //定义一个const整型变量ca，可进行的操作：读
//ca = 200; //给ca进行写操作，操作错误，ca只能进行读操作；
//const int cb; //定义一个const整型变量cb，可进行的操作：读，但是未初始化，无可读内容，操作错误
int const cb = 100; //定义一个const整型变量cb，该操作等价ca

int *p = &a;
p = &b;
*p = 200;
const int *cp1 = &a;
cp1 = &b;
//*cp1 = 200; //const直接修饰*cp1,,*cp1不可修改
int const *cp2 = &a; //定义一个const整型变量cp2，并保存a的地址，该操作等价cp1
cp2 = &b; //*cp2不可修改
int *const cp3 = &a; //cp3不可修改，不可保存其他地址，cp3与cp2不为同一类型
*cp3 = 200; //*cp3可修改

int const *const ccp = &a; //cpp和*cpp均不可修改
//ccp = &b;//error //error
//*ccp = 100;//error //error

return 0;
}