有关sizeof、strlen处理字符串的问题

先贴上一份完整的代码：

#include <stdio.h>
#include <string.h>

void func(char str[50]) 
{ 
    printf("A %d B %d ",sizeof(str), strlen(str)); 
} 
int main(void) 
{ 
    char stra[] = "HelloWorld"; 
    char *strb = stra; 
    printf("C %d D %d ",sizeof(stra), sizeof(strb++)); 
    func(++strb); 
    printf("E %d F %d\n",strlen(stra), strlen(strb++)); 
    return 0; 
}
/*
C = 11,计算包括'\0'
D = 4, 指针
A = 4, 尽管形参是数组，但传递的依然是指针
B = 9, 因为++strb, 使得strb = "elloWorld".
E = 10, '\0'之前的所有字符
F = 9, 同上分析。
*/

注意：sizeof(“数组名”)的时候 会自动添加上’\0’所以位数+1；
注意：strlen(“数组名”) 确切的数就是看里面实际添加了多少个有效数值；
注意：char name[2]=“ab”;可以吗？
注意：char str[20]=“0123456789”;
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20; 而不是10！！

char  str2[5] = {'H','e','l','l','o'};
	 printf("G %d H %d\n",sizeof(str2), strlen(str2)); //strlen 出错  因为没有'\0'
char  str1[] = “Hello”;
     sizeof (str1 ) = 6    (自动加了'\0')  
     strlen (str1 ) = 5    (字符串的长度) 
 //strlen:计算长度，到’\0’为止
 //sizeof:计算字符数组大小（包括’\0’）

char  *p1 = "Hello";
sizeof ( p1 ) =  4    (p1是一个指针，大小为4)

char  *p2[]={"hello","world"};
sizeof ( p2 ) =  8    (p2是长度为2的字符串数组)

 
int    n = 10;
int    *q = &n;
sizeof ( n ) =   4    (整型大小为4)
sizeof ( q ) =   4    (q是一个指针，大小为4)

2.动态分配内存

int *p = (int *)malloc( 100 );
sizeof ( p ) = 4      (p是一个指针，大小为4)

3.函数参数

void Function1( char p[],int num ){
    sizeof ( p ) = 4  (数组在作为函数参数时均化为指针)
}
void Function2( int p[],int num ){
    sizeof ( p ) = 4  (数组在作为函数参数时均化为指针)
}

// 数组作为参数传递时均作为指针传递，所以sizeof=4

多重继承

class A{};
class B{};
class C : public A, public B{};
class D : virtual public A{};
class E : virtual public A, virtual public B{};
//sizeof(A) = 1，sizeof(B) = 1		(空类大小为1,编译器安插一个char给空类，用来标记它的每一个对象)
//sizeof ( C ) = 1      (继承或多重继承后空类大小还是1)
//sizeof(D) = 4 (虚继承时编译器为该类安插一个指向父类的指针，指针大小为4）
//sizeof(E) = 8  (指向父类A的指针与父类B的指针，加起来大小为8）

sizeof(A) = 1   sizeof(B) = 1  sizeof ( C ) =1 sizeof(D) =4 sizeof(E) = 8

5.数据对齐

类(或结构)的大小必需为类中最大数据类型的整数倍.CPU访问对齐的数据的效率是最高的，因此通常编译浪费一些空间来使得我们的数据是对齐的
class A{
public:
    int a;
};
class B{
public:
    int a ;
    char b;
};
class C{
public:
    int a ;
    char b;
    char c;
};
sizeof(A) = 4  （内含一个int ，所以大小为4）
sizeof(B) = 8   (int为4，char为1，和为5，考虑到对齐，总大小为int的整数倍即8)  
sizeof(C) = 8   (同上)

附：【转】
1.sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned int类型。
该类型保证能容纳实现所建立的最大对象的字节大小。

2.sizeof是算符，strlen是函数。

3.sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以’’\0’'结尾的。
sizeof还可以用函数做参数，比如：
short f();
printf("%d\n", sizeof(f()));
输出的结果是sizeof(short)，即2。

4.数组做sizeof的参数不退化，传递给strlen就退化为指针了。

5.大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因
char str[20]=“0123456789”;
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;

6.strlen的结果要在运行的时候才能计算出来，时用来计算字符串的长度，不是类型占内存的大小。

7.sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。

8.当适用了于一个结构类型时或变量， sizeof 返回实际的大小，
当适用一静态地空间数组， sizeof 归还全部数组的尺寸。
sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸

9.数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址，
如：
fun(char [8])
fun(char [])
都等价于 fun(char *)
在C++里参数传递数组永远都是传递指向数组首元素的指针，编译器不知道数组的大小
如果想在函数内知道数组的大小， 需要这样做：
进入函数后用memcpy拷贝出来，长度由另一个形参传进去
fun(unsiged char p1, int len)
{
unsigned char buf = new unsigned char[len+1]
memcpy(buf, p1, len);
}