assert AND 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;
}