sizeof 面试题

#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, 同上分析。
*/

1.常规
char  str1[] = “Hello”;
sizeof (str1 ) = 6    (自动加了'\0')  
strlen (str1 ) = 5    (字符串的长度)  

 

char  str2[5] = {'H','e','l','l','o'};
sizeof (str2 ) = 5    (字符数组的大小)
strlen (str2)  = 未知 (该字符串缺少结束符'\0')

 

char  str3[6] = {'H','e','l','l','o','\0'};

sizeof (str3)  = 6    (字符数组的大小)
strlen (str3)  = 5    (该字符串的长度为5)

?  sizeof:计算字符数组大小（包括’\0’）

?  strlen:计算长度，到’\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.

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）

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   (同上)

6.函数与虚函数
编译器为每个有虚函数的类都建立一个虚函数表（其大小不计算在类中）,并为这个类安插一个指向虚函数表的指针，即每个有虚函数的类其大小至少为一个指针的大小4
class A {
public:
    int a;
    void Function();
};

class B {
public:
    int a;
    virtual void Function();
};

class C : public B{
public:
    char b;
};

class D : public B{
public:
    virtual void Function2();

     /*

     Int a;  继承来的

     Vptr *p; 虚函数指针

*/

};

class E{
public:
    static void Function();
};
sizeof (A) = 4   (内含一个int,普通函数不占大小)
sizeof (B) = 8   (一个int ,一个虚函数表指针)
sizeof (C) =12   (一个int ,一个虚函数表指针，一个char ,再加上数据对齐)
sizeof (D) = 8   (一个int ,一个虚函数表指针,多个虚函数是放在一个表里的，所以虚函数表指针只要一个就行了)
sizeof (E) = 1   (static 函数不占大小,空类大小为1)

7.父类的私有数据
虽然在子类中不可用，但是是可见的，因此私有的数据还是要占子类的大小
class A{
private:
    int a;
};
class B:public A{};
sizof(B) = 4;    (内含一个不可用的父类的int）

 

Sizeof与Strlen的区别与联系(转）

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);
}