C/C++语言杂谈

//  sizeof不能用来计算字符串的长度，计算字符串长度的函数为strlen() 函数，strlen函数计算字符串长度的时候不包含后面的‘\0’，用 sizeof 求数组所占用的字节的时候，当是字符串数组时，计算 sizeof 的时候会计算后面的 ‘\0’ 结束标志，如： char arr [ ] = {"abcdefg"};  那么 sizeof(arr) = 8;

// 一般的参数传递属于值传递，当数组作为参数传递的时候，是地址传递，在子函数里面有两种写法：

1、void  function( char  str[ ] )

2、void  function( char *str )

（也可以是其他类型）

3、联合体（union）的大小取决于它所有的成员中占用空间最大的一个成员的大小，并且对于符合数据类型，如  union、struct、class 的对齐方式为成员中最大成员的对齐方式。

32 为系统中，int 占4个字节，short 占2个字节，char 占1个字节，double 占8个字节，float 占4个字节，long 占4个字节

#include<iostream.h>

union  u

{

double  a;

int  b;

};

union  u2

{

char  a[13];

int  b;

};

union  u3

{

char  a[13];

char  b;

};

对于 u 来说，其大小就是最大的 double 类型成员 a 了，所以 sizeof（u）== sizeof（double）== 8

对于 u2 来说，最大的是 char [13] 类型的数组，但是由于另一个成员 int b 的存在，u2 的对齐方式也就是 4，所以 u2 的大小必须在 4 上对齐，占用的空间由 13 变为了 16

对于 u3 来说，大小也就是 sizeof（u3）== 13

但是对齐的方式是可以更改的：

#include<iostream.h>

#pragma pack(2)  // 编译器对齐方式取为 2

union u

{

char  str[9];

int  a;

};

C++ 里面固有类型的对齐方式取编译器对齐方式与自身大小中较小的一个

上面的程序中，由于使用了手动更改对齐方式为2，所以 int 的对齐方式也变为了 2 ，虽然 int 自身的大小为 4 ，u 的对齐成员中，最大的对齐也是 2 ，因此sizeof （u）== 10

//  用指针赋值

#include<stdio.h>

int main()

{

char a [ ] = "hello, world";

char  *ptr = a;

printf ("%c \n", *(ptr + 4));

printf ("%c\n", ptr [ 4 ]);

printf ("%c\n", a[4]);

printf("%c\n",*(a+4));

*(ptr + 4) + =1;

printf ("%s\n", a);

return 0;

}

ptr[4] 和 *(ptr + 4) 是一样的，并且也和 a[4] 和*（a+4）是一样的，都是字母 o。

而*（ptr+4）+ =1 也就是相当于 a[4] = a[4] + 1，即 a[4] 的值为 p（这里用到了强制类型转换）

输出为：o o o o p

// 对字符串数组进行初始化的时候，必须在定义的同时进行初始化，而不能先定义，再初始化

比如：

char  arr [ ];

arr = {" hello , world ! "};

这样赋值是不行的，因为 arr 是数组的首地址，是一个常量，所以不能把常量赋值给常量，必须按照下面的赋值方式

 char arr [ ] = { " hello,world! " };

or

char arr [ ] = {‘h’,'e','l','l','o',' ','w','o','r','l','d','!'};

单个赋值和以字符串的形式赋值有一点不同是在字符串赋值的时候，数组最后会有一个 ‘ \0 ’ 默认字符串结束的字符，所以也比单个赋值多了一个字节

// 三维动态数组的定义和释放

#include<stdio.h>

#inlcude<stdlib.h>

int main()

{

int  ***arr ;

int n1,n2,n3;

int i,j,k;

scanf("%d%d%d",&n1,&n2,&n3);

if((arr=(int ***)malloc(n1*sizeof(int **)))==NULL)        // 第一维数组的创建

{

printf("分配内存空间失败！\n")；

return 0;

}

for (i=0;i<n1;i++)

{

if((arr[i]=(int **)malloc(n2*sizeof(int *)))==NULL)  // 第二维数组的创建

{

printf("分配内存失败！\n")；

return 0;

}

for(j=0;j<n2;j++)

{

if((arr[i][j]=(int *)malloc(n3*sizeof(int)))==NULL)  // 第三维数组的创建

{

printf("分配内存失败！\n")；

return 0;

}

}

}

for(i=0;i<n1;i++)

for(j=0;j<n2;j++)

for(k=0;k<n3;k++)

{

arr[i][j][k]=i+j+k+1;

printf("%d ",arr[i][j][k]);

}

for(i=0;i<n1;i++)

for(j=0;j<n2;j++)

free(arr[i][j]);         //释放第三维

for(i=0;i<n1;i++)

free(arr[i]);   // 释放第二维

free(arr);    //释放第一维

return 0;

}

// 一般选择前缀方式递增递减：++n 而不是后缀的形式：n++

// 函数完整的声明方法：

[修饰符]  返回类型  名称（参数） [override] [const] [final]

其中的方括号是可选项，而不是字面上的意思，final 表示后面可以有很多，如果修饰符有多个，那么他们之间用空格分开，而不是逗号，比如声明一个既是 static 又是 inline 的函数：  static  inline  int  hello_world（）;

// 函数可以重载的唯一条件是参数的类型不同，即使是返回值类型不同，但是如果参数类型相同的话，那也是不可以重载的，比如：

int  hello_world（int n）;  和 double  hello_world( double n ); 这样是可以重载的，但是下面的却不行

int  hello_world  （int n）;和 double  hello_world( int n ); 这样编译器就会报错：重载函数不够唯一

// const 关键字的用法，最重要的一条规则是：一个非 const 的值可以作为 const 参数被传递，但一个 const 值不能作为非 const 值被传递，如：

<span style="font-size:18px;">const double pi = 3.1415926;
void display_value(const double &x);
display_value(pi);// 这样是可以的
// 或者下面也是可以的
double x=3.15;
void display_value(const double &x)
display_value(x);// 把非const 值转换为
// const值，但是下面的是不行的：
const double pi = 3.1415926;
void display_value(double &pi)
display_value(pi);</span>