1、字符数组和字符串
首先区分两个名词:字符数组和字符串
字符数组:首先它是一个数组,然后它存储的元素是字符。如char ch[3]={};
字符串:用双引号包围的字符序列。在C中为了标志一个字符串的结束,会在字符序列的最后一个字符后添加'\0',以标志字符串的结束。
下面来看具体的例子:
- char ch[3] = {'a', 'b', 'c'};
- char *p = "abc";
再看一个例子:
- char ch[] = "abc";
- #include <iostream>
- using namespace std;
- int main()
- {
- char ch[3] = {'a', 'b', 'c'};
- char *p = "abcdefg";
- char array[] = "abcdefg";
- cout<<sizeof(ch)<<endl; //3
- cout<<sizeof(p)<<endl; //4
- cout<<sizeof(array)<<endl; //8
- return 0;
- }
这是因为p的类型是char*,也即p是一个指针变量,指针变量在32位系统中占用4字节;而array的类型为char[8], 所以会占用8个字节。
这里有一个细节需要注意:"abcdefg"是存储在静态常量区。p是栈区的一个指针,指向该位于静态常量区的字符串;array也是位于栈区,但是用一个字符串常量来初始化一个栈区的字符数组,会在栈区开辟一段空间,然后将字符串常量拷贝到栈区,所以array就占有8个字节了,这时候它存储的只是字符串常量的一个副本,更改array数组,并不能更改字符串常量。示例如下:
- #include <iostream>
- using namespace std;
- int main()
- {
- char *p = "abcdefg";
- char array[] = "abcdefg";
- array[3] = 'a';
- while (*p)
- {
- cout<<*p;
- p++;
- }
- cout<<endl;
- cout<<array<<endl;
- return 0;
- }
输出结果:
abcdefg
abcaefg
另外需要注意的一个问题是:p指向的是一个常量区的字符串,该字符串是不允许被更改,即它是只读的。为了防止疏忽,即通过指针p来修改常量,通常将p声明为const char*.
2、还有一个特别需要注意的问题:当数组作为函数的参数时,它又占用多大的内存呢?
对于数组参数,编译器把它解释为普通的指针类型,如void fun(char ch[10], char *p),ch的类型是char*,而不是char[10], p的类型是char*,这样p和ch占用的内存都是4个字节。
下面看一道面试题,练习一下。
- char array[] = "abcdefg";
- printf("%d\n",sizeof(array)); // 8
- char ch[7] = "abcd";
- printf("%d\n", sizeof(ch)); //7
- char *p = "abcdefg";
- printf("%d\n",sizeof(p)); // 4
- void func(char p[10])
- {
- printf("%d\n",sizeof(p)); // 4
- }
- void func(char (&p)[10])
- {
- printf("%d\n",sizeof(p)); // 10
- }
- int main(void)
- {
- printf("%d\n",sizeof(char[2])); // 2
- printf("%d\n",sizeof(char&)); // 1
- return 0;
- }
3、上面所讲的其实都是关于sizeof()对于字符相关变量的操作,字符操作还有另一个常用的函数strlen()
- extern unsigned int strlen(char *s)
函数求的是字符串的实际长度,它求得方法是从开始到遇到第一个'\0'.
- #include <iostream>
- using namespace std;
- int main()
- {
- char str1[3] = {'a', 'b', 'c'};
- char str2[10] = {'a', 'b', 'c'};
- char str3[10] = "abc";
- char str4[] = "abc";
- char *str5 = "abc";
- cout<<strlen(str1)<<endl; //非正确值,因为找不到'\0'
- cout<<strlen(str2)<<endl; //3
- cout<<strlen(str3)<<endl; //3
- cout<<strlen(str4)<<endl; //3
- cout<<strlen(str5)<<endl; //3
- return 0;
- }
变量名称的后面部分比前面部分具有更强的约束力。
所以,如下变量声明:
int **a[3][6];
cout<<"a="<<sizeof(a)<<endl; //72 a为一个有3*6个指针元素的数组
cout<<"a="<<sizeof(*a)<<endl; //24 *a为数组一维的6个指针
cout<<"a="<<sizeof(**a)<<endl; //4 **a为一维的第一个指针
cout<<"a="<<sizeof(***a)<<endl; //4 ***a为第一个数组内容为指针
cout<<"a="<<sizeof(****a)<<endl; //4 ****a为一个int变量
表示“int **”类型的二维数组(“[]”比“int”和“*”更具有约束力)。这个二维数组共有18个成员(3×6),每个成员是一个指针(int **),每个指针的长度是4(如果是32位计算机,其他位计算机可以类推)。所以,这个数组的长度为:18 × 4 = 72。
首先要说明的int **a[3][6]
的意思是定义一组指向指针变量的二维指针数组,
也就是说,定义了一个 3 行 6 列的指针数组,每个指针都指向一个指针,
从存储结构上来说,就是一个存储了 18 个指针变量的数组,
这里的 a 指的到底是什么 ,
a 本身实际含义是一个地址 , 表示 a[3][6] 这个数组的首地址,
就 a 作为一个个地址来说,它占用 4 个字节;
同时 a 也是 a[3][6] 这个数组一种表示 ,
如果用 sizeof(a) 去求解的话 , 它代表的是 a[3][6] 这个数组所占用的空间 ,
而不是 a 这一个地址所占用的存储空间 ,
也就是 18 个指针变量所占的空间 , 自然是 72 个字节了 .
double* (*a)[3][6];
cout<<sizeof(a)<<endl; // 4 a为指针
cout<<sizeof(*a)<<endl; // 72 *a为一个有3*6个指针元素的数组
cout<<sizeof(**a)<<endl; // 24 **a为数组一维的6个指针
cout<<sizeof(***a)<<endl; // 4 ***a为一维的第一个指针
cout<<sizeof(****a)<<endl; // 8 ****a为一个double变量
既然a是执行double*[3][6]类型的指针,*a就表示一个double*[3][6]的多维数组类型,因此sizeof(*a)=3*6*sizeof(double*)=72。同样的,**a表示一个double*[6]类型的数组,所以sizeof(**a)=6*sizeof (double*)=24。***a就表示其中的一个元素,也就是double*了,所以sizeof(***a)=4。至于****a,就是一个double了,所以sizeof(****a)=sizeof(double)=8。