C language - the difference between sizeof and strlen

sizeof and strlen The difference between ：

　　1.sizeof The result type of the operator is size_t, It's in the header file typedef by unsigned int type .

　　　　 This type is guaranteed to hold the byte size of the largest object created by the implementation .

　　2.sizeof It's an operator ,strlen Is the function .

　　3.sizeof You can use type as a parameter ,strlen Only use char* Make parameters , And it must be based on ''\0'' At the end of the .

　　　　sizeof You can also use functions as parameters , such as ：

　　　　　　short f();

　　　　　　printf("%d\n",sizeof(f()));

　　　　 The output is zero sizeof(short), namely 2.

　　4. Array do sizeof The parameters of do not degenerate , Pass to strlen It degenerates into a pointer .

　　5. Most compilers Just compile it sizeof It's been calculated It's the length of a type or variable, and that's what it is sizeof(x) The reason that can be used to define the dimension of an array

　　　　charstr[20]="0123456789";

　　　　int a=strlen(str);//a=10;

　　　　int b=sizeof(str);// and b=20;

　　6.strlen The results of the test can only be calculated at run time , Is used to calculate the length of a string , Not the size of the type in memory .

　　7.sizeof If it is a type, it must be bracketed , If it's a variable name, you can leave it out of brackets . This is because sizeof It's an operator, not a function . For variables ,sizeof( Variable name ) and sizeof Variable name , The effect is the same ; If used for type ,sizeof( type ) That's right. ,sizeof type Will be an error .

　　8. When applied to a structure type or variable , sizeof Returns the actual size ,

　　　　 When applying a static array of spaces , sizeof Return all array sizes .

　　　　sizeof The operator cannot return the size of an array that is dynamically allocated or an external array

　　9. When an array is passed to a function as a parameter, it passes a pointer instead of an array , Passing is the first address of the array

The main differences are as follows ：
1、sizeof It's the operator ,strlen yes C Language standard library functions .
2、 strlen It measures the actual length of the string , With ’\0’ end , The returned result does not include ’\0’ .
3、 and sizeof It measures the allocated size of characters , Its parameters can be arrays 、 The pointer 、 type 、 object 、 Functions, etc .
To be specific , When the parameters are as follows ,sizeof The meaning of the returned value is as follows ：

Array - The amount of array space allocated at compile time ;

The pointer - The amount of space used to store the pointer ;

type - The size of the space occupied by this type ;

object - The actual space occupied by the object ;

function - The space occupied by the function return type ;

Example 1：

struct test{
        int a;
        int b;
        int c;
};
 struct test *A;

char *str1=“absde”;
char str2[]=“absde”;
char str3[8]={‘a’,};
int str4[8]={‘a’,};
char ss[] = “0123456789”;

Output ：

sizeof(*A);   //12, The calculated size of the whole structure .

sizeof(A);   //4, Calculate the size of the pointer .

sizeof(str1); // 4, It calculates the size of pointer memory , Include ’\0’

sizeof(*str1); // 1, It calculates the size of the first element of the array

sizeof(*(str1+1)); // 1, It calculates the size of the second element of the array
sizeof(str2); // 6 , It calculates the memory size of the string , Include ’\0’
sizeof(str3); // 8 , The calculation is char Memory size of type array
sizeof(str4); // 32 , The calculation is int Memory size of type array
sizeof(ss); // 11 , It calculates the size of the string , Include ’\0’
strlen(str1); // 5 , The length of the string is calculated , barring ‘\0’
strlen(str2); // 5 , The length of the string is calculated , barring ‘\0’
strlen(str3); // ？ , Because the string needs to be found ’\0’ To end , To be in ’a’ And then I found ’\0’, So it's a random value
strlen(str4); // ？ , Because the string needs to be found ’\0’ To end , To be in ’a’ And then I found ’\0’, So it's a random value
strlen(ss); // 10 , The length of the string is calculated , barring ‘\0’