C语言可以给字符数组赋值的方法

转载 2012年04月06日
 10:23:36

标签：
语言 /
c


31190


学了这么多年的C语言，突然发现连字符串赋值都出错，真的很伤心。


char a[10];

怎么给这个数组赋值呢？

1、定义的时候直接用字符串赋值

char a[10]="hello";

注意：不能先定义再给它赋值，如char a[10]; a[10]="hello";这样是错误的！

2、对数组中字符逐个赋值

char a[10]={'h','e','l','l','o'};

3、利用strcpy

char a[10]; strcpy(a, "hello");


易错情况：

1、char a[10]; a[10]="hello";//一个字符怎么能容纳一个字符串？况且a[10]也是不存在的！

2、char a[10]; a="hello";//这种情况容易出现，a虽然是指针，但是它已经指向在堆栈中分配的10个字符空间，现在这个情况a又指向数据区中的hello常量，这里的指针a出现混乱，不允许！

C语言的运算符根本无法操作字符串。在C语言中把字符串当作数组来处理，因此，对字符串的限制方式和对数组的一样，特别是，它们都不能用C语言的运算符进行复制和比较操作。


直接尝试对字符串进行复制或比较操作会失败。例如，假定str1和str2有如下声明：

char str1[10], str2[10];

利用=运算符来把字符串复制到字符数组中是不可能的：

str1 = "abc";     /*** WRONG ***/

str2 = str1;       /*** WRONG ***/

C语言把这些语句解释为一个指针与另一个指针之间的（非法的）赋值运算。但是，使用=初始化字符数组是合法的：

char str1[10] = "abc";

这是因为在声明中，=不是赋值运算符。

试图使用关系运算符或判等运算符来比较字符串是合法的，但不会产生预期的结果：

if (str1==str2) ...    /*** WRONG ***/

这条语句把str1和str2作为指针来进行比较，而不是比较两个数组的内容。因为str1和str2有不同的地址，所以表达式str1 == str2的值一定为0。
原始网址：http://blog.chinaunix.net/space.php?uid=7390305&do=blog&id=2057100

同C语言中其它数据类型一样，字符串也有常量和变量之分。字符串常量是由双引号括起来的一串字符。如"string"就是字符串常量，printf和scanf函数中的"%d%d"也是字符串常量。
C语言本身并没有设置一种类型来定义字符串变量，所以字符串的存储完全依赖于字符数组，但字符数组并不等于是字符串变量。下面介绍给一维字符数组赋初值的方法。
1.将所赋初值放在一对花括号中，如： charstr[10]={'s','t','r','i','n','g','\0'};
此处赋初值时，人为地在最后一个有效字符后加入了串结束标志'\0'。而如果所赋初值的字符个数少于数组的元素时，系统将自动在其后所有的元素中加入串结束标志'\0'。因此，上述赋初值语句也可以写成： charstr[10]={'s','t','r','i','n','g'};
由此可知，当使用一个字符数组来存放一个字符串时，数组的大小至少要比实际存放的最长字符串多一个元素，多出的这个元素用于存放串结束标志。否则，系统会将其视为一个普通的一维字符数组来处理。
2.当用赋初值的方式来定义字符数组大小时，这时的定义应写成： charstr[]={'s','t','r','i','n','g','\0'};
若上面的定义写成： charstr[]={'s','t','r','i','n','g'};
则是错误的，因为所赋初值的末尾没有串结束标志。也就是说，上面的形式只是定义了一个有6个元素的字符数组。
可以直接用字符串常量给一维字符数组赋初值，例如： charstr[10]={"string"};
习惯上均省略花括号，简写成： charstr[10]="string";
同样应注意的是字符数组大小要比字符串多一个元素，用以存放字符串结束标志。上述定义也可以写成： charstr[]="string";
系统将按字符串实际的字符个数来定义数组的大小，在此数组 str 将包含7个元素(含系统自动加的'\0')。

个人博客网址：https://ljsblog.com
数组（四）
数组是一组相同类型元素的集合
一维数组的创建方式
数组元素类型 数组名[常量表达式];

例：
//例1
int arr1[10];
//例2
char arr2[3];
float arr3[5];
double arr4[10];
//错误示例
int n=10;
int arr5[n];//创建数组时，[]中要给一个常量，不能使用变量

一维数组的初始化
//完全初始化,定义数组时给所有元素赋初值，例：
int arr[5]={1,2,3,4,5};
//不完全初始化，给数组中部分元素赋初值，其余元素自动为0：例：
int arr1[5];={1,2};//a[0]=1 a[1]=2,其余元素自动为0
//如果定义数组时就给数组中所有元素赋初值，那么就可以不指定数组的长度，因为此时元素的个数已经确定了。例：
int arr2[]={1,2,3,4,5}//数组元素个数自动为5

sizeof和strlen
sizeof:计算变量，类型，数组的大小，单位是字节，sizeof是运算符。

strlen:需要引入头文件string.h，求字符串长度，只能针对字符串，从字符串的开头位置依次向后计数，遇到\0返回字符串长度，字符串长度不包括\0，strlen是函数。

例子:
#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[]="myblog";
	char arr2[]={'m','y','b','l','o','g'};
	printf("%d\n",sizeof(arr1));//7
	printf("%d\n",sizeof(arr2));//6
	printf("%d\n",strlen(arr1));//6
	printf("%d\n",strlen(arr2));//随机值
	return 0;
}

一维数组的使用
[]是下标引用操作符，数组是使用下标来访问的，下标是从0开始，元素个数是可以通过计算得到的

例:
#include <stdio.h>
int main()
{
	int a[]={1,2,3,4,5};
	int i=0,sz=0;
	sz=sizeof(a)/sizeof(a[0]);
	for(i=0;i<sz;i++)
	{
		printf("%d\n",a[i]);
	}
	return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
	char a[]="abcde";
	int i=0,sz=0;
	sz=(int)strlen(a);//strlen返回值是无符号数
	for(i=0;i<sz;i++)
	{
		printf("%c\n",a[i]);
	}
	return 0;
}

一维数组的存储
数组在内存中是连续存储的，例。
//取数组每个元素地址
#include <stdio.h>
int main()
{
	int a[]={1,2,3,4,5};
	int i=0,sz=0;
	sz=sizeof(a)/sizeof(a[0]);
	for(i=0;i<sz;i++)
	{
		printf("a[%d]=%p\n",i,&a[i]);
	}
	return 0;
}

/*打印结果为:
a[0]=007DF988
a[1]=007DF98C
a[2]=007DF990
a[3]=007DF994
a[4]=007DF998
*/

二维数组的创建
数组元素类型 数组名[行数][列数];
int arr[3][4];
/*
定义一个3行4列的整型数组，数组名为arr，即
a[0][0], a[0][1], a[0][2], a[0][3]
a[1][0], a[1][1], a[1][2], a[1][3]
a[2][0], a[2][1], a[2][2], a[2][3]
*/
char arr[3][5];//3行5列
double arr[2][3];//2行3列

二维数组的初始化
例1：
int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
/*
a[0][0]=1  a[0][1]=2  a[0][2]=3  a[0][3]=4
a[1][0]=5  a[1][1]=6  a[1][2]=7  a[1][3]=8
a[2][0]=9  a[2][1]=10 a[2][2]=11 a[2][3]=12
*/

例2：
int a[3][4]={{1,2},{3,4}};
/*
a[0][0]=1  a[0][1]=2  a[0][2]=0  a[0][3]=0
a[1][0]=3  a[1][1]=4  a[1][2]=0  a[1][3]=0
a[2][0]=0  a[2][1]=0  a[2][2]=0  a[2][3]=0
*/
//部分元素初始化，其余元素自动补0

例3：
int a[][4]={{1,2,3,4},{5,6,7,8}};
/*
a[0][0]=1  a[0][1]=2  a[0][2]=3  a[0][3]=4
a[1][0]=5  a[1][1]=6  a[1][2]=7  a[1][3]=8
*/
//创建二维数组中行可以省，列不可以省

二维数组的使用
#include <stdio.h>
int main()
{
	int a[3][4]={{1,2,3},{4,5}};
	int i=0,j=0;
	for(i=0;i<3;i++)
	{
		for(j=0;j<4;j++)
		{
			printf("a[%d][%d]=%-2d ",i,j,a[i][j]);
		}
		printf("\n");
	}
	return 0;
}
/*
打印结果
a[0][0]=1  a[0][1]=2  a[0][2]=3  a[0][3]=0
a[1][0]=4  a[1][1]=5  a[1][2]=0  a[1][3]=0
a[2][0]=0  a[2][1]=0  a[2][2]=0  a[2][3]=0
*/

二维数组的存储
二维数组在内存中也是连续存储的，例:
#include <stdio.h>
int main()
{
	int a[3][4];
	int i=0,j=0;
	for(i=0;i<3;i++)
	{
		for(j=0;j<4;j++)
		{
			printf("&a[%d][%d]=%p\n",i,j,&a[i][j]);
		}
	}
	return 0;
}
/*
&a[0][0]=0076F914
&a[0][1]=0076F918
&a[0][2]=0076F91C
&a[0][3]=0076F920
&a[1][0]=0076F924
&a[1][1]=0076F928
&a[1][2]=0076F92C
&a[1][3]=0076F930
&a[2][0]=0076F934
&a[2][1]=0076F938
&a[2][2]=0076F93C
&a[2][3]=0076F940
可以看出二维数组每个元素的地址在内存中也是连续的
*/
//二维数组可以看作是由多个一维数组组合而成，如果一个数组的每个元素又是一个数组，那么这个数组就是二维数组。所以一个二维数组也可以分解为多个一维数组。

注意事项
数组名是数组首元素地址，但有两种情况例外

sizeof(数组名)，计算整个数组大小，sizeof内部单独放一个数组名，数组名表整个数组
&数组名，取出的是整个数组的地址，数组名表整个数组

例子：冒泡排序
#include <stdio.h>
void Bubble_Sort(int arr[],int sz)
{
	int i=0,j=0,flag,tmp;
	for(i=0;i<sz-1;i++)
	{
		flag=0;
		for(j=0;j<sz-1-i;j++)
		{
			if(arr[j]>arr[j+1])
			{
				tmp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=tmp;
				flag=1;
			}
		}
		if(flag==0)
		{
			break;
		}
	}
}
int main()
{
	int arr[]={9,8,7,6,5,4,3,2,1};
	int i=0;
	int sz=sizeof(arr)/sizeof(arr[0]);
	Bubble_Sort(arr,sz);
	for(i=0;i<sz;i++)
	{
		printf("%d ",arr[i]);		
	}
	return 0;
}

指针数组
1、什么是指针数组；
（1）数组里面的每一个元素不是值而是指针。

（2）把很多的指针集合在一起，就是一个指针数组
2、定义一个指针数组：
类型标识符  *数组名[长度]；

比如：int *a[4];

定义了一个数组名为a,它里面含有几个四个元素，他们分别是a[0],a[1],a[2],a[3],它们每个都是一个指针。
3、如何给指针数组赋初值：
//其中a是一个普通数组，b是指针数组，即b数组当中的每一个值都是指针
int a[3] = {1,2,3},*b[3]={a,a+1,a+2};
printf("%d",*b[0]);

a		---------->		a[0]		<--------b[0]

a+1		------>		a[1]		<--------b[1]

a+2		------>		a[2]		<--------b[2]
#include<stdio.h> 
void main(){
	int a[4]={1,2,3,4},*b[4]={a,a+1,a+2,a+3};
	*b[0]=*b[0]+1;//2
	*b[1]=*b[1]+1;//3
	printf("%d,%d",a[0],a[1]);//2 3
}



变换
 #include<stdio.h> 
void main(){
	int a[4]={1,2,3,4},*b[4]={a,a+1,a+2,a+3};
	*b[0]=*b[0]+1;//2
	*b[1]=*b[1]+1;//3
	printf("%d,%d,%d",a[0],a[1],**b);//2 3 2
}


**(p+1) 和 *(*p+1)的区别
	#include<stdio.h> 
void main(){
	int a=1,b=4,*p[2]={&a,&b};
	**(p+1)=a*b;//b=a*b=4
	*(*p+1)=a+b;//*(p[0]+1)
	printf("a=%d,b=%d",a,b);
}



变换
#include<stdio.h> 
void main(){
 
 	char *aa[2]={"abcd","ABCD"};
	printf("%s",*(aa+1));
}