C语言中的字符串（从定义到传参）

字符串的定义：
其实字符串也可以认为是一个字符数组，只是多了一个\0。

#include<stdio.h>
int main()
{
	char sty[3]={'c','s','d'};//不合法，不能代表一个字符串。
	char str[4]={'c','s','d','\0'};//合法，注意到'\0'也要占一个位置。
	char app[]={"csd"};//同样没有任何问题，当然，省略大括号也可以，没有任何问题。
	//你甚至可以把一行写不下的写道两行，当然估计这种情况仅局限于考试。
	char abb[]="c"
				"s d";//注意第一行就没了分号哦
	return 0;
}

字符指针：
第一种是用指针指向了一个字符常量的首地址
第二种则是指向了一个字符串的首地址

//我懒得再写头文件了
//同时懒得再写主函数 
char*p="csd";//第一种用法
char str[]="csd";
char *pp=str;//第二种写法

接下来就比较麻烦了。
我们先不管这两种写法的区别，先看一个简单点的东西。
字符串的输入与输出。
最标准的输入与输出：

for(int i=0;i<n;i++)
	scanf("%c",&str[i]);
for(int i=0;i<n;i++)
	printf("%c",str[i]);

这种会按你的“n”来一个个恪守规矩的输入和输出，也就是它不会管你输入有没有结束，即使你敲回车也只会存在字符里，直到你敲够了n个，再敲回车，输入才算结束，输出也是一样，他不会管你中间有没有\0，都会一个个给你输出。
让我们回到上上个问题，我们讨论一下这两种输出和修改。

printf("%c",*(p+1));
printf("%c",*(pp+1));
//这两种在输出没有任何区别
//但如果想修改其中的内容，就会有差异。

第一种定义方法是只读的，也就是只是指向一个常量内存单元，是不可以被修改的，当然，你可以令这个指针指向另一个常量，但第二种定义方法就可以进行修改，因为你指向的是一个首地址。代码如下

//第一种修改的方法
p="sdn";
//第二种修改方法
*(p+1)='o';

之所以第一个不带星是因为我要修改的是p所指向的地址，但第二个我要修改的是字符串中的内容，所以不需要加上星号。
当然，如果这些简单的 看懂了，来一些更加有趣的代码会锦上添花

#include<stdio.h>
int main()
{
	int a[]={1,2,3,4};
	int *p=a;
	printf("%d,",*p);//p指向a的首地址
	printf("%d,",*(++p));//指针p右移，指向了下一个地址
	printf("%d,",(*p)++);//指针p指向的地址，++没有起任何做用
	printf("%d,",*p);//上一个++在这步体现了作用，对里面的数据进行了修改
	printf("%d,",*p--);//减减对数据进行了修改
	printf("%d,",--(*p));//对里面数据进行了修改
	printf("%d\n",*p);//和上面的一样
	return 0;
}

所以最终输出的结果是
1，2，2，3，3，0，0
再来个更有趣的
统计并输出字符串中的单词
这里是how are you

#include<stdio.h>
void Print(char*arr[],int len)
{
	int i;
	for(i=0;i<len;i++)//实现输出这个字符串
	{
		printf("%s ",arr[i]);
		/*for(int j=0;j<sizeof(arr[i]);j++)
		{
			printf("%c",arr[i][j]);
		}*/
		//作为一个常量的首地址时，我们可以利用%s进行输出，亦可以一个个读取来进行输出；
	}
	printf("\n");
}
int main()
{
	char*pArray[]={"How","are","you"};//用字符串常量进行初始化，该数组存的是指针类型，是四个字节
	int num=sizeof(pArray)/sizeof(char*);//注意一下不能用char，char*是四个字节，而char是一个
	printf("Total string numbers = %d\n",num);//算错了
	Print(pArray,num);
	return 0;
}

字符串函数：
这里没别的东西了，直接上代码：

#include<stdio.h>
#include<string.h>
int main()
{
	char str[10];
	gets(str);//不能限制字符串的长度，优势是自动处理回车
	fgets(str,sizeof(str),stdin);//可以避免缓冲区的溢出，使输入符合字符串的长度
	puts(str);//自动换行
	strlen(str);//字符串长度检测
	strcpy(str1,str2);//把str2的给str1
	strncpy(str1,str2,n);//复制n个
	strcmp(str1,str2);// 字符串比较
	//大于返回大于0的值，等于返回0，小于返回小于0的值
	strcmp(str1,str2,n);//字符串比较n个
	strcat(str1,str2);//字符串连接
	strncat(str1,str2,n);//字符串连接n个
	return 0;
}

关于二维数组指针传递：
一维数组传递是这样的

void ppp(int a[])
{}
main()
{
	ppp(a);
}

但在二维数组里，a[]就代表了一行数组的首地址，所以必须将看起来一个四不像的 数据传进去。

#include<stdio.h>
int sdde(int a[])
{
	printf("%d",a[1]);
	return 0;
}

int main()
{
	int a[2][2]={{1,2},{3,4}};
	sdde(a[0]);
	return 0;
}

当我们看完函数传数组的时候，我们应当认真考虑 如何传递一个字符串。
我们通过一个 转置矩阵来看看怎么实现传参

#include<stdio.h>//转置矩阵
#define N 11
#define M 11
void Transpose(int a[][N],int at[][M],int m,int n)
{
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<=n;j++)
		{
			at[j][i]=a[i][j];
		}
	}
}
int main()
{
	int m,n;
	int a[M][N];
	int at[N][M];
	scanf("%d%d",&m,&n);
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<n;j++)
		{
			scanf("%d",&a[i][j]);
		}
	}
	Transpose(a,at,m,n);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			printf("%d",at[i][j]);
			if(j!=m-1)
				printf(" ");
		}
		printf("\n");
	}
	return 0;
}

作为第一种首先亮相的传参形式，它传过去的参数是一个二维数组的首地址，对应的函数接口里则是一个建立好的二维数组

#include<stdio.h>//转置矩阵
#define N 11
#define M 11
void Transpose(int (*a)[N],int (*at)[M],int m,int n)
{
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<=n;j++)
		{
			at[j][i]=a[i][j];
		}
	}
}
int main()
{
	int m,n;
	int a[M][N];
	int at[N][M];
	scanf("%d%d",&m,&n);
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<n;j++)
		{
			scanf("%d",&a[i][j]);
		}
	}
	Transpose(a,at,m,n);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			printf("%d",at[i][j]);
			if(j!=m-1)
				printf(" ");
		}
		printf("\n");
	}
	return 0;
}

这种传参形式与上一种一样，依然传过去的是一个二维数组的首地址，但函数的接口发生了变化，这个变化其实并不大，因为在二维数组中（*a)是一个数组的行首地址，其实还是和原来那个数据接受方式是一样的。
手动分割线
最后一种迷惑性传参来了

#include<stdio.h>//转置矩阵
#define N 11
#define M 11

//二维数组传递参数的方法3
void Transpose3(int *a,int *at,int m,int n)
{
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<n;j++)
		{
			*(at+j*11+i)=*(a+i*11+j);
		}
	}
}
int main()
{
	int m,n;
	int a[M][N];
	int at[N][M];
	scanf("%d%d",&m,&n);
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<n;j++)
		{
			scanf("%d",&a[i][j]);
		}
	}
	Transpose3((int*)&a[0][0],(int*)&at[0][0],m,n);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			printf("%d",at[i][j]);
			if(j!=m-1)
				printf(" ");
		}
		printf("\n");
	}
	return 0;
}

不得不说，这种传参真实又迷惑又麻烦
这种传参方式重点的是二维数组的定义
如果你定义了一个二维数组，那么它是以一个长方体的形式储存的，这种传参方式传过去了一个首地址，接收的时候并没有把他当二维数组来接受，但由于函数可以直接访问这个二维数组的地址，所以会自动换行！！！这也是完成转置那么费劲的原因。
return code;