目录
break与continue
break : 结束所有循环
continue:结束本次循环
例:1+2+3+4+5+.......m > 1000,求m的最小值
-
#include<stdio.h>
-
int Fun()
-
{ int sum=0;
-
int i;
-
for(i=0; ;i++)
-
{ sum+=i;
-
if(sum>1000) break;
-
}
-
return i;
-
}
-
int main()
-
{
-
printf("%d",Fun());
-
return 0;
-
}
C数组
C 语言支持数组数据结构,它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据,但它往往被认为是一系列相同类型的变量。
数组的声明并不是声明一个个单独的变量,比如 number0、number1、...、number99,而是声明一个数组变量,比如numbers,然后使用 numbers[0]、numbers[1]、...、numbers[99] 来代表一个个单独的变量。数组中的特定元素可以通过索引访问。
所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素,最高的地址对应最后一个元素,数组的下标从0开始
数组名代表数组首元素的首地址
初始化数组
-
int array={0,1,2,3,4}; // 在定义数组时同时初始化
-
int brr[5]; // 此时数组brr中的值为随机值
-
brr={1,2,3,4,5} // 数组初始化只有一次机会
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
用 for 循环初始化数组
-
int main()
-
{
-
int arr[5];
-
for(int i = 0;i < 5;i++) //注意边界问题
-
{
-
arr[i] = i;
-
}
-
}
C语言提供了几种聚合类型(aggregate types),即相同类型的数据集合,包括数组、指针、结构、共用体(联合)、位域和枚举等。
1、数组存放在哪个位置? 数组分配的是一块栈上的内存
2、数组什么时候确定大小? 编译时
3、什么时候给数组分配内存?运行时
4、数组越界的原理是什么? 栈是受保护的,变量之间有两个哨兵位保护
5、最多分配多大的内存?根据栈大小分配 1M-2M
数组在内存中如何存放?
-
int main()
-
{
-
int a = 10;
-
int b = 20;
-
int arr[5] = {1,2,3,4,5};
-
printf("%d,%d,%d,%d\n",&a,&b,&arr[0],&arr[4]);
-
return 0;
-
}
sizeof()
-
sizeof(arr); //代表整个数组的字节数
-
int arr[5]={1,2,3,4,5}
-
int len =sizeof(arr)/sizeof(arr[0]) // 20/4,此语句必须和数组定义位置在一起
-
void Show(int *p,int len)
-
{
-
//int len = sizeof(p)/sizeof(p[0]); //错误error,要与数组定义在一起
-
for(int i = 0;i < len;i++)
-
{
-
printf("%d ",p[i]); //*(p+i); *解引用 []:自带解引用
-
}
-
printf("\n");
-
}
-
int main()
-
{
-
int arr[5] = {1,2,3,4,5};//20
-
int len = sizeof(arr)/sizeof(arr[0]); //sizeof(arr):代表整个数组的字节数 20/4 = 5
-
Show(arr,len); //地址 数组首元素的地址
-
}
数组名能否作为左值或者右值?
数组内部详解
对于数组来说是否可以整体赋值,对于变量来说,我们可以赋值,但是数组可以吗?为什么?
对于定义的数组 int arr[5],数组名是啥,内存当中是如何存储的?
指针
指针是一个变量,其值为另一个变量的地址,即,内存位置的直接地址。
-
int *p; //野指针
-
int *p = NULL; //0号地址 不能访问0号地址
-
printf("%d",p[i]) // *(p+i); *解引用 []自带解引用
-
int *p p+1表示p向后挪4个字节(int* 类型)
一个任何类型的指针变量所占的字节大小都为4个字节
-
int *p=&a
-
int **pp=&p
-
int ***ppp=&pp
一级指针:变量的地址
二级指针:存放的是一级指针的地址
-
int a = 10;
-
int *p = &a; //一级指针存放变量地址 即 p=&a
-
int **p = &p; //二级指针存放的是一级指针的地址
常量指针
int * const p,p是一个常量类型的指针,不能修改这个指针的指向,但是这个指针所指向的地址上存储的值可以修改。
-
int const *p=&a
-
*p=100(正确,可以修改指针所指向的地址上存储的值)
-
p=&b(错误,不能修改指针指向)
指向常量的指针
const int *p,定义一个指针指向一个常量,不能通过指针来修改这个指针指向的值
-
const int *p=&a
-
*p=100(错误,不能修改指针所指向的地址上存储的值)
-
p=&b(正确,可以修改指针指向)
访问数组中的元素
数组名有两种情况代表的是整个数组:
1、sizeof(arr); //整个数组的字节大小
2、&arr+1; //数组最后一个元素的后面
访问数组当中元素的方法:
1、可以通过下标去访问
2、通过指针的形式访问
-
int arr[5] = {5,4,3,2,1};
-
int len = sizeof(arr)/sizeof(arr[0]);
-
int *p = arr; //p指向arr数组的首元素
-
int a = *p+3; //*p+3为arr数组首元素的值加3
-
printf("%d\n",a);
-
printf("%d\n",&arr); //数组名代表首元素的首地址
-
printf("%d\n",&arr+1); //&arr+1代表首地址加数组的length
-
printf("%d\n",&arr[0]); //arr[0]的地址
-
printf("%d\n",&arr[4]); //arr[4]的地址
-
printf("%d\n",arr); //数组名代表首元素的首地址
断言(assert)的使用
原型定义:void assert( int expression );
assert宏的原型定义在<assert.h>中,其作用是先计算表达式 expression ,如果expression的值为假(即为0),那么它先向stderr打印一条出错信息,然后通过调用abort 来终止程序运行。
标准C中的断言函数assert(),如果断言函数的参数为0时将触发断言函数的执行,会在运行时程序崩溃。
字符数组
-
char crr[5]={'a','b','c','d'}; //字符数组,元素用单引号,最后补'\0'(结束标志)
-
char crr[5]={'a','b','c','d','e'}; //此时最后无'\0', %s打印时会遇到错误
-
char crr[5]="abcd"; //也是字符数组,最后默认加 '\0'
-
char crr[5]="abcde"; //错误,默认最后加 '\0'
数组的整体赋值只有一次机会——初始化
-
char crr4[10] = "abcdef";
-
crr4[0] = 'g';
-
char crr5[10] = crr4; //error,数组的整体赋值只有一次机会——初始化
".rodata"段存放的是只读数据,一般是程序里面的只读变量(如const修饰的变量)和字符串常量。单独设立".rodata"段有很多好处,不光是在语义上支持了C++的const关键字,而且操作系统在加载的时候可以将".rodata"段的属性映射成只读,这样对于这个段的任何修改操作都会作为非法操作处理,保证了程序的安全性。另外在某些嵌入式平台下,有些存储区域是采用只读存储器的,如ROM,这样将".rodata"段放在该存储区域中就可以保证程序访问存储器的正确性。
-
char *const str = "tulun"; //str字符串,默认会有一个'\0'
-
printf("%s\n",str); /打印字符串,默认最后加 '\0',%s打印时遇到'\0'便结束
-
*(str+1)='g'; //error,试图修改str字符串中的值,在rodata段(readonly段,内容不能修改)
-
printf("%d\n",sizeof(str)); //值为4,因为任何类型指针变量的长度都为4个字节
'\0' '0' "0" 0的区别
在C语言中,字符是按其所对应的ASCII码来存储的,一个字符占一个字节
-
char ch1 = 0x00; //0
-
char ch3 = 0; //0
-
char ch4 = '\0'; //0
-
char ch2 = '0'; //48
'0' 和 "0"
"0"是字符串常量,字符串常量是由一对双引号括起的字符序列。如:"123"。'0'是字符常量,字符串常量和字符常量是不同的量。
字符常量由单引号括起来;字符串常量由双引号括起来
字符常量只能是单个字符;字符串常量则可以含一个或多个字符
'\0' 和 '0'
它们都是字符,在C/C++语言中,字符是按其所对应的ASCII码来存储的,一个字符占一个字节。第一个ASCII码是0,对应的字符是Null,其实就是'\0',即空字符。判断一个字符串是否结束的标志就是看是否遇到'\0','\0'表示字符串结束。字符'0'对应的ASCII码是48,通常用字符转化为数字会用到,比如要将'7'转换为数字7,即 '7'-'0'。但是字符常量也可以像整数一样在程序中参与相关运算。如:'7'-3;此时要注意它是把'7'转换成对应的ASCII码再运算。
sizeof与strlen的区别与联系
sizeof 返回的是变量声明后所占的内存数,不是实际长度,计算时包括 '\0',此外sizeof不是函数,仅仅是一个操作符,strlen是函数。
strlen()是一个函数,测量的是字符的实际长度,以'\0' 结束,但计算时不包括 '\0'
-
char str1[100] = "abcdef";
-
char *str2 = "abcdef";
-
char str3[] = "abcdef";
-
char str4[100] = "abcdef\0xyz";
-
char *str5 = "abcdef\0xyz";
-
char str6[] = "abcdef\0xyz";
-
char str7[] = "abcdef\n\0";
-
char *str8 = "abcdef\n\0";
-
printf("%d,%d\n",sizeof(str1),strlen(str1)); // 100 6
-
printf("%d,%d\n",sizeof(str2),strlen(str2)); // 4 6
-
printf("%d,%d\n",sizeof(str3),strlen(str3)); // 7 6
-
printf("%d,%d\n",sizeof(str4),strlen(str4)); // 100 6
-
printf("%d,%d\n",sizeof(str5),strlen(str5)); // 4 6
-
printf("%d,%d\n",sizeof(str6),strlen(str6)); // 11 6
-
printf("%d,%d\n",sizeof(str7),strlen(str7)); // 9 7
-
printf("%d,%d\n",sizeof(str8),strlen(str8)); // 4 7
字符串与字符数组
字符串存放在rodata段,值不可修改,存储在相同区域
-
char *str = "hello"; //字符串,存放在rodata段,不可修改
-
char *str2 = "hello";
-
printf("%d %d",str,str2); //str,str1指向同一区域,值相等
字符数组存放在read段,值可修改 ,存储在不同区域
-
char str3[] = "hello"; //字符数组,存放在read区
-
char str4[] = "hello";
-
printf("%d %d",str3,str4); //str3,str4值不相等
数组名不能做左值
-
int arr[]={1,2,3,4};
-
arr++; //error,arr++即arr=arr+1,arr是指针常量,指向数组首元素的首地址,数组名不能做左值
例:int a[10]={1,2,3},下列哪个不可以可以表示a[1]? A
A. a+sizeof(int); a+4;
B. &a[0]+1;
C. (int *)&a+1;
D. (int *)((char*)&a+sizeof(int));
-
//【a是int型指针,a+1相当于加4个字节】
-
//分析:
-
a+sizeof(int); // a+4;相当于加16字节,表示a[4]
-
&a[0]+1; //加4字节,表示a[1]
-
(int *)&a+1 //加4字节,表示a[1]
-
(int *)(&a+1) // (&a+1)相当于一个整体, 指向数组末尾最后的地址
-
(int *)((char*)&a+sizeof(int))
-
//将int型指针a强制转换成char型指针,(char*)&a+4表示加4字节
strcpy()字符串拷贝函数
-
char *str="Tulun";
-
char *str2="Hello";
-
printf("%s\n",strcpy(str,str2)); //error,字符串不能修改
下面程序会产生栈溢出错误,编译器先打印再报错 ,库函数在return后才会检查报错。
-
char *str2="Hello";
-
char str3[5]={};
-
printf("%s\n",strcpy(str3,str2)); //error,str3[5]栈溢出,需修改为str3[6]
编写一个与strlen功能相同的函数:
-
int My_strlen(char *src)
-
{
-
int len = 0;
-
while(*src++ != '\0')
-
{
-
len++;
-
//src = src+1;
-
//src++;
-
}
-
return len;
-
}
编写一个与strcpy功能相同的函数:
方法一:
-
void My_strcpy(char *dest,const char *src)
-
{
-
int i = 0;
-
for(i = 0;src[i] != '\0';i++)
-
{
-
dest[i] = src[i];//*(src+i)
-
}
-
dest[i] = '\0';//手动赋值\0
-
}
方法二:
-
void My_strcpy2(char *dest,const char *src)
-
{
-
assert(dest != NULL && src != NULL);
-
while(*src != '\0')
-
{
-
*dest = *src;
-
dest++;//dest+1
-
src++;//src+1
-
}
-
*dest = '\0';
-
}
方法二进阶:
-
void My_strcpy3(char *dest,const char *src)
-
{
-
assert(dest != NULL && src != NULL);
-
while(*dest++ = *src++) {}
-
}
方法三:
-
char * My_strcpy4(char *dest,const char *src)
-
{
-
//char *p = dest;
-
assert(dest != NULL && src != NULL);
-
while(*dest++ = *src++) {}
-
return dest; //走到最后'\0'
-
//return p;
-
}