C程序设计 04-06 数组和指针

最新推荐文章于 2024-08-19 16:46:26 发布

小麦China

最新推荐文章于 2024-08-19 16:46:26 发布

阅读量108

点赞数

分类专栏： C与C++程序设计文章标签： c++

本文链接：https://blog.csdn.net/qq_35683407/article/details/116451232

版权

C与C++程序设计专栏收录该内容

9 篇文章 0 订阅

订阅专栏

本文详细介绍了C语言中的数组、指针及字符串操作，包括数组的初始化、内存存放、sizeof与strlen的区别，以及指针的使用、常量指针和指向常量的指针。此外，还探讨了字符数组、字符串与字符数组的关系，并展示了如何使用strcpy进行字符串拷贝。通过对这些基础知识的深入理解，有助于提升C语言编程技能。

摘要由CSDN通过智能技术生成

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

小麦China

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C程序设计 04-06 数组和指针

目录break与continueC数组初始化数组用 for 循环初始化数组数组在内存中如何存放？sizeof()数组名能否作为左值或者右值？数组内部详解指针常量指针指向常量的指针访问数组中的元素断言(assert)的使用字符数组'\0' '0' "0" 0的区别sizeof与strlen的区别与联系字符串与字符数组strcpy()字符串拷贝函数break与continuebreak : 结束所有循环conti...
复制链接

扫一扫

专栏目录