Strlen和Sizeof函数的区别
求字符串长度
字符串的长度通常是指字符串中包含字符的数目，但有的时候人们需要的是字符串所占字节的数目。
常见的获取字符串长度的方法包括如下几种。
1.使用sizeof获取字符串长度sizeof的含义很明确，它用以获取字符数组的字节数（当然包括结束符0）。
对于ANSI字符串和UNICODE字符串，形式如下：1.sizeof(cs)/sizeof(char)2.sizeof(ws)/sizeof(wchar_t)可以采用类似的方式，获取到其字符的数目。
如果遇到MBCS，如"中文ABC"，很显然，这种办法就无法奏效了，因为sizeof()并不知道哪个char是半个字符。
2.使用strlen()获取字符串长度strlen()及wcslen()是标准C++定义的函数，它们分别获取ASCII字符串及宽字符串的长度，如：1.size_t strlen( const char *string );2.size_t wcslen( const wchar_t *string );strlen()与wcslen()采取0作为字符串的结束符，并返回不包括0在内的字符数目。
3.使用CString::GetLength()获取字符串长度CStringT继承于CSimpleStringT类，该类具有函数：1.int GetLength( ) const throw( );GetLength()返回字符而非字节的数目。
比如：CStringW中，"中文ABC"的GetLength()会返回5，而非10。
那么对于MBCS呢？同样，它也只能将一个字节当做一个字符，CStringA表示的"中文ABC"的GetLength()则会返回7。
4.使用std::string::size()获取字符串长度basic_string同样具有获取大小的函数：1.size_type length( ) const;2.size_type size( ) const;length()和size()的功能完全一样，它们仅仅返回字符而非字节的个数。
strlen总结
strlen（C语言函数）strlen所作的仅仅是一个计数器的工作，它从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结束符'\0'为止，然后返回计数器值(长度不包含'\0')。
头文件：cstring string.h功能：计算给定字符串的长度区别sizeofstrlen(char*）函数求的是字符串的实际长度，它求得方法是从开始到遇到第一个'\0'，如果你只定义没有给它赋初值，这个结果是不定的，它会从aa首地址一直找下去，直到遇到'\0'停止。
char aa[10];cout<<strlen(aa)<<endl; //结果是不定的char aa[10]={'\0'}; cout<<strlen(aa)<<endl; //结果为0char aa[10]="jun"; cout<<strlen(aa)<<endl; //结果为3（此处不完全正确，结果可能是不定的，如果编译器将其他的非零字符串放在aa[10]的内存地址后，strlen结果还是不定的，MSP430在IAR编译测试过）（但是在vc6中结果为3，编译器会在“处自动添上\0。
）char aa[5]="hello";cout<<strlen(aa)<<endl; //结果5（此处不完全正确，理由如上，因为实际内存中，hello后面不一定是空（即\0））（还应视编译器而定）而sizeof（）返回的是变量声明后所占的内存数，不是实际长度，此外sizeof不是函数，仅仅是一个取字节运算符，strlen是函数。
sizeof(aa) 返回10int a[10]; sizeof(a) 返回40 （根据语言int型c 是四个字节c++是四个java 是两个）⒈sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned int类型。
Sizeof与Strlen的区别与联系
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);}我们能常在用到 sizeof 和 strlen 的时候，通常是计算字符串数组的长度。
C++基础面真题
1.const符号常量：〔1〕、const char Xp〔2〕、char const Xp〔3〕、char X const p如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量。
如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。
2.析构函数和虚函数的用法和作用？析构函数的作用是当对象生命期结束时释放对象所占用的资源。
析构函数用法：析构函数是特别的类成员函数它的名字和类名相同，没有返回值，没有参数不能随意调用也没有重载。
只是在类对象生命期结束时有系统自动调用。
虚函数用在继承中，当在派生类中需要重新定义基类的函数时需要在基类中将该函数声明为虚函数，作用为使程序支持动态联遍。
3.堆和栈的区别栈〔stack〕：由编译器自动分配释放，存放函数的参数值，局部变量的值等。
其操作方法类似于数据结构中的栈。
堆：一般由程序员分配释放，假设不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分成分法类似。
4.头文件的作用是什么？1.通过头文件来调用库功能。
在很多场合，源代码不便〔或不准〕向用户公布，只要向用户提供头文件和二进制的库即可。
用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么完成的。
编译器会从库中提取出相应的代码。
2.头文件能加强类型平安检查。
如果某个接口被完成或被使用时，其方法与头文件中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的负担。
5.内存的分成分法有几种？1.从静态存储地域分配。
内存在程序编译的时候已经分配好，这块内存在程序的整个运行期间都存在。
如全局变量。
2.在栈上创立。
在执行函数时，函数内局部变量的存储单元都可以在栈上创立，函数执行结束时这些存储单元自动被释放。
栈内存分配运算内置于处理器的指令集中，效率高，但是分配的内存容量有限。
3.从堆上分配，亦称动态内存分配。
程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。
c语言获取字符串长度的函数
c语言获取字符串长度的函数摘要：1.函数strlen()2.函数sizeof()3.自定义函数计算字符串长度正文：在C 语言中，获取字符串长度的函数有以下几种：1.函数strlen()strlen() 函数是C 语言标准库中的一个函数，用于计算字符串的长度。
它接受一个字符指针作为参数，并返回字符串中字符的个数，不包括字符串结束符"0"。
使用strlen() 函数时，需要包含头文件<string.h>。
例如，假设有一个字符串"hello, world!"，我们可以通过以下代码计算其长度：```c#include <stdio.h>#include <string.h>int main() {char str[] = "hello, world!";int length = strlen(str);printf("字符串长度为：%d", length);return 0;}```2.函数sizeof()sizeof() 函数是C 语言中的一个运算符，用于计算数据类型或变量在内存中占用的字节数。
我们可以使用sizeof() 函数来计算字符串的长度，但这种方法只适用于字符数组，而不适用于字符指针。
例如，我们可以通过以下代码计算字符串"hello, world!"的长度：```c#include <stdio.h>int main() {char str[] = "hello, world!";int length = sizeof(str) / sizeof(str[0]);printf("字符串长度为：%d", length);return 0;}```这里，我们首先计算字符数组str 在内存中占用的字节数，然后除以字符数组中每个字符的字节数（在C 语言中，字符占用一个字节），得到字符串的长度。
第3章 数组(习题答案及解析)
习题3 参考答案一、选择题3.1 C 分析：本题考查程序和数组的基本概念。
3.2 A 分析：字符串比较大小是以第1个不相同字符的大小为标准的，跟长度没有关系，B选项不正确；字符串比较大小除了使用库函数strcn3()以外，就只能靠自己写代码来实现了，而不能通过关系运算符来比较大小。
因为字符串在表达式中相当于const char*，即常字符指针，代表的是字符串的首地址，关系运算符会将两个字符串的首地址值比较大小，这是毫无意义的。
C选项不正确。
C语言中只有字符串常量而没有字符串变量，D选项描述不正确；空串的长度为0，而以空格打头的字符串的长度至少为1，因此A选项是正确。
3.3 A 分析：如果第一维的长度没有指定，则定义的同时需要完成初始化，否则不知道分配多大的内存空间给它，所以选项B、C错误；二维数组a[2][3]中只有两个元素，都是一维数组，一维下标最大只能是a[1]，所以选项D错误；若完成初始化的二维数组，第一维的长度没有指定，则第一维的大小按如下规则确定：若初值个数能被第二维大小整除，所得的商就是第一维的大小，若不能整除，则所得的商加1作为第一维的大小，所以选项A相当于：double a[1][3] = {6}；其中a[0][0]=6，其他元素赋值0，选项A正确，答案为A。
3.4 D 分析：本题考察的知识点是：字符串常量。
在C语言中，字符串常量是以双引号括起来的字符序列。
因此B选项和C选项不正确。
字符序列中可包含一些转义字符，转义字符都是以"\"开头的。
A选项中包含了三个"\"，前两个(\\)代表了一个"\"字符，后面一个和"""一起(\")被看作一个"""，所以该字符串缺少一个结束的"""，因此不正确。
D选项的两个"""之间没有任何字符，代表的是一个空串，是合法的字符串常量，因此D选项正确。
CC++程序员面试指南
char *p = (char *)malloc(100); strcpy(p, “ before”); free(p); //p 所指向的内存被释放，但是 p 的值不变 if(p != NULL) //检测不到错误 strcpy(p, “ after”); 为了避免这种情况，指针在 free 之后应赋值为 NULL。 3、 指针超越了变量的作用范围,这种情况让人防不胜防。 #include<iostream.h> void f(A *p) class A { { A a; public: p = &a; void Func(void) p->Func(); { } value = 3; void main(void) cout<<”in fun of A”<<endl; { } A *p; public: f(p); //a 的作用域结束 int value; p->Func(); // p 成了野指针 }; } 函数 f 结束时，变量 a 被释放，p 指向了垃圾内存，但是在 main 函数中又用 p 调用了 Fun， 而此时 p 所指向的内存不可用（a 释放后 p 就成了野指针） ，将导致内存操作错误。 常见的一道题： void GetMemory(char *p) { p = (char *)malloc(100); } void Test(void) { char *str = NULL; getMemory(str); //执行完这句之后，str 的值仍为 NULL,如果想改变指针的值 strcpy(str,”hello world”);//GetMemory 的参数要为二级指针 printf(str); } ############################################################################### void *GetMemory(void) { char p[] = “ hello world”; return p; } void Test(void) { char *str = NULL; str = getMemory()();
C语言经典面试题目及答案详解(三)
C语言经典面试题目及答案详解（三）接着更新C语言面试题，希望能帮助到大家！1、变量的声明和定义有什么区别为变量分配地址和存储空间的称为定义，不分配地址的称为声明。
一个变量可以在多个地方声明，但是只在一个地方定义。
加入 extern 修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分定义。
说明：很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化，分配内存空间，如外部变量。
2、写出 bool 、int、 float、指针变量与“零值”比较的if 语句bool 型数据： if( flag ) {A; } else {B； } int 型数据： if( 0 != flag ) {A; } else {B； }指针型数： if( NULL == flag ) {A; } else {B； } float 型数据： if ( ( flag >= NORM ) && ( flag <= NORM ) ) {A； }注意：应特别注意在 int、指针型变量和“零值”比较的时候，把“零值”放在左边，这样当把“==”误写成“=”时，编译器可以报错，否则这种逻辑错误不容易发现，并且可能导致很严重的后果。
3、sizeof 和 strlen 的区别sizeof 和 strlen 有以下区别：1. sizeof 是一个操作符，strlen 是库函数。
2. sizeof 的参数可以是数据的类型，也可以是变量，而strlen 只能以结尾为‘\0‘的字符串作参数。
3. 编译器在编译时就计算出了 sizeof 的结果。
而 strlen 函数必须在运行时才能计算出来。
并且 sizeof 计算的是数据类型占内存的大小，而 strlen 计算的是字符串实际的长度。
4. 数组做 sizeof 的参数不退化，传递给 strlen 就退化为指针了。
注意：有些是操作符看起来像是函数，而有些函数名看起来又像操作符，这类容易混淆的名称一定要加以区分，否则遇到数组名这类特殊数据类型作参数时就很容易出错。
2019CC++《阿里》面试题总结
2019CC++《阿⾥》⾯试题总结⼀、C和C++的区别是什么？C是⾯向过程的语⾔，C++是在C语⾔的基础上开发的⼀种⾯向对象编程语⾔，应⽤⼴泛。
C中函数不能进⾏重载，C++函数可以重载C++在C的基础上增添类，C是⼀个结构化语⾔，它的重点在于算法和数据结构。
C程序的设计⾸要考虑的是如何通过⼀个过程，对输⼊（或环境条件）进⾏运算处理得到输出（或实现过程（事务）控制），⽽对于C++，⾸要考虑的是如何构造⼀个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。
C++中struct和class除了默认访问权限外，别的功能⼏乎都相同。
⼆、关键字static、const、extern作⽤static和const的作⽤在描述时主要从类内和类外两个⽅⾯去讲：static关键字的作⽤：（1）函数体内static变量的作⽤范围为该函数体，该变量的内存只被分配⼀次，因此其值在下次调⽤时仍维持上次的值；（2）在模块内的static全局变量和函数可以被模块内的函数访问，但不能被模块外其它函数访问；（3）在类中的static成员变量属于整个类所拥有，对类的所有对象只有⼀份拷贝；（4）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因⽽只能访问类的static成员变量。
const关键字的作⽤：（1）阻⽌⼀个变量被改变（2）声明常量指针和指针常量（3）const修饰形参，表明它是⼀个输⼊参数，在函数内部不能改变其值（4）对于类的成员函数，若指定其为const类型，则表明其是⼀个常函数，不能修改类的成员变量(const成员⼀般在成员初始化列表处初始化)（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为”左值”。
extern关键字的作⽤：（1）extern可以置于变量或者函数前，以标⽰变量或者函数的定义在别的⽂件中，提⽰编译器遇到此变量和函数时在其他模块中寻找其定义。
sizeof 用法(非常全面)
4. 基本数据类型的sizeof
这里的基本数据类型指short、int、long、float、double这样的简单内置数据类型，由于它们都是和系统相关的，所以在不同的系统下取值可能不同，这务必引起我们的注意，尽量不要在这方面给自己程序的移植造成麻烦。
c1的偏移量为0，s的偏移量呢这时s是一个整体，它作为结构体变量也满足前面三个准则，所以其大小为8，偏移量为4，c1与s之间便需要3个填充字节，而c2与s之间就不需要了，所以c2的偏移量为12，算上c2的大小为13，13是不能被4整除的，这样末尾还得补上3个填充字节。最后得到sizeof(S3)的值为16。
sizeof( 2 ); // 2的类型为int，所以等价于 sizeof( int );
sizeof( 2 + 3.14 ); // 3.14的类型为double，2也会被提升成double类型，所以等价于 sizeof( double );
sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用，我们来看一个完整的例子：
c语言中判断数据类型长度符的关键字
用法
sizeof(类型说明符，数组名或表达式);
或
sizeof 变量名
1. 定义：
sizeof是C/C++中的一个操作符（operator），简单的说其作用就是返回一个对象或者类型所占的内存字节数。
MSDN上的解释为：
The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types). This keyword returns a value of type size_t.
sizeof用法
sizeof()sizeof是运算符，可用于任何变量名、类型名或常量值，当用于变量名（不是数组名）或常量时，它不需要用圆括号。
它在编译时起作用，而不是运行时。
这是初学者问得最多的一个问题，所以这里有必要多费点笔墨。
让我们先看一个结构体：struct S1{char c;int i;};问sizeof(s1)等于多少聪明的你开始思考了，char占1个字节，int 占4个字节，那么加起来就应该是5。
是这样吗你在你机器上试过了吗也许你是对的，但很可能你是错的！VC6中按默认设置得到的结果为8。
Why为什么受伤的总是我请不要沮丧，我们来好好琢磨一下sizeof的定义——sizeof的结果等于对象或者类型所占的内存字节数，好吧，那就让我们来看看S1的内存分配情况：S1 s1 = { 'a', 0xFFFFFFFF };定义上面的变量后，加上断点，运行程序，观察s1所在的内存，你发现了什么以我的VC6.0为例，s1的地址为0x0012FF78，其数据内容如下：0012FF78: 61 CC CC CC FF FF FF FF发现了什么怎么中间夹杂了3个字节的CC看看MSDN上的说明：When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.原来如此，这就是传说中的字节对齐啊！一个重要的话题出现了。
为什么需要字节对齐计算机组成原理教导我们这样有助于加快计算机的取数速度，否则就得多花指令周期了。
为此，编译器默认会对结构体进行处理（实际上其它地方的数据变量也是如此），让宽度为2的基本数据类型（short等）都位于能被2整除的地址上，让宽度为4的基本数据类型（int等）都位于能被 4整除的地址上，以此类推。
C++面试常见问题
C++⾯试常见问题指针和引⽤的区别指针是⼀个变量，存储的是⼀个地址，引⽤跟原来的变量实质上是同⼀个东西，是原变量的别名指针可以有多级，引⽤只有⼀级指针可以为空，引⽤不能为NULL且在定义时必须初始化指针在初始化后可以改变指向，⽽引⽤在初始化之后不可再改变sizeof指针得到的是本指针的⼤⼩，sizeof引⽤得到的是引⽤所指向变量的⼤⼩当把指针作为参数进⾏传递时，也是将实参的⼀个拷贝传递给形参，两者指向的地址相同，但不是同⼀个变量，在函数中改变这个变量的指向不影响实参，⽽引⽤却可以。
引⽤只是别名，不占⽤具体存储空间，只有声明没有定义；指针是具体变量，需要占⽤存储空间。
引⽤在声明时必须初始化为另⼀变量，⼀旦出现必须为typename refname &varname形式；指针声明和定义可以分开，可以先只声明指针变量⽽不初始化，等⽤到时再指向具体变量。
引⽤⼀旦初始化之后就不可以再改变（变量可以被引⽤为多次，但引⽤只能作为⼀个变量引⽤）；指针变量可以重新指向别的变量。
不存在指向空值的引⽤，必须有具体实体；但是存在指向空值的指针。
堆和栈的区别申请⽅式不同：栈由系统⾃动分配；堆是⾃⼰申请和释放的。
申请⼤⼩限制不同：栈顶和栈底是之前预设好的，栈是向栈底扩展，⼤⼩固定，可以通过ulimit -a查看，由ulimit -s修改；堆向⾼地址扩展，是不连续的内存区域，⼤⼩可以灵活调整。
申请效率不同：栈由系统分配，速度快，不会有碎⽚；堆由程序员分配，速度慢，且会有碎⽚。
区别以下指针类型int *p[10]int (*p)[10]int *p(int)int (*p)(int)int *p[10]表⽰指针数组，强调数组概念，是⼀个数组变量，数组⼤⼩为10，数组内每个元素都是指向int类型的指针变量。
int (*p)[10]表⽰数组指针，强调是指针，只有⼀个变量，是指针类型，不过指向的是⼀个int类型的数组，这个数组⼤⼩是10。
C++编程考试测试题2
(1)const char *p
(2)char const *p
(3)char * const p
(4)const char * const p
说明上面四种描述的区别
2、指针和引用的区别
3、sizeof与strlen的区别
4、STL中的Vector和List有什么区别
5、定义一个处理日期的类TDate，它有3个私有数据成员：Month,Day,Year和若干个公有成员函数，并实现如下要求：①构造函数重载；②成员函数设置缺省参数；③定义一个友元函数来打印日期；④可使用不同的构造函数来创建不同的对象。
strcpy(name,fname); cout<<'?';
}
};
int main(){
Name names[3]={Name("张三"), Name("李四")};
return 0;
}
运行此程序输出符号? 的个数是
A.0B.1C.2D.3
40,以下程序的输出结果是
intf(int b[],int m,int n)
则b的值为
A．A)语法错误B)1C)2D)不一定
30,运算符”+”、”<”、”||”、”/”按照优先级从高到低排序为( )
A)”/、+、||、<”B)”||、<、/、+”C)”/、+、<、||”D)”<、||、/、+”
31,下列说法错误的是( )
A）公有继承时基类中的public成员在派生类中仍是public的
{
int i,s=0;
for(int i=m;i<n;i=i+2) s=s+b[i];
sizeof的用法
sizeof()用法汇总sizeof()功能：计算数据空间的字节数1.与strlen()比较strlen()计算字符数组的字符数，以"\0"为结束判断，不计算为'\0'的数组元素。
而sizeof计算数据（包括数组、变量、类型、结构体等）所占内存空间，用字节数表示。
2.指针与静态数组的sizeof操作指针均可看为变量类型的一种。
所有指针变量的sizeof 操作结果均为4。
注意：int *p; sizeof(p)=4;但sizeof(*p)相当于sizeof(int);对于静态数组，sizeof可直接计算数组大小；例：int a[10];char b[]="hello";sizeof(a)等于4*10=40;sizeof(b)等于6;注意：数组做型参时，数组名称当作指针使用！！void fun(char p[]){sizeof(p)等于4}经典问题：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]类型数组的指针。
既然是指针，所以sizeof(a)就是4。
既然a是执行double*[3][6]类型的指针，*a就表示一个double*[3][6]的多维数组类型，因此sizeof(*a)=3*6*sizeof(double*)=72。
strlen和sizeof的区别
strlen和sizeof的区别strlen 是⼀个库函数，计算传进来的字符串的长度，以 ‘\0’结尾sizeof 是⼀个运算符，它计算的是传进来的指针在内存中所占空间⼤⼩，在编译时就已经获得了结果。
C语⾔中没有字符串，⽤的是字符数组来模拟字符串。
C风格的字符串时字符数组然后在末尾加0表⽰结尾。
//在C语⾔中有strlen和sizeof两个函数求字符数组的长度函数，他们俩的区别就是是否把最后的结束标志也加上去。
//错误//strlen是不加的，他表⽰字符串的长度。
//错误⽽sizeof求的是字符串在内存中的长度，所以它是加上最后的'\0'的//所以⼀般⽽⾔后者的长度会⽐前者多1。
//错误#include<stdio.h>#include<string.h>int main(){char buf[] = "abcd";printf("sizeof(buf) = %d\n",sizeof(buf));printf("strlen(buf) = %d\n",strlen(buf));return1;}运⾏结果：exbot@ubuntu:~/shareWin/CAndC++$ ./sizeofandstrlensizeof(buf) = 5strlen(buf) = 4它们相差 1 并不是 sizeof 和 strlen 的问题，⽽是 buf 没有指定空间⼤⼩，直接初始化后需要多少空间在后⾯+1，所以表现出来的效果显⽰成sizeof结果⽐strlen⼤1strlen计算的是字符串到'\0'位置的⼤⼩sizeof计算的字符串占的内存⼤⼩#include<stdio.h>#include<string.h>int main(){char str[100] = {0};strcpy(str, "abcd");int str_len = strlen(str);int str_size = sizeof(str);printf("strlen(str) = %d\n", (str_len));printf("sizeof(str) = %d\n", (str_size));return0;}运⾏结果：ubuntu@ubuntu:~/workspace/test$ gcc sizeofAndStrlen.c -o sizeofAndStrlenubuntu@ubuntu:~/workspace/test$ ./sizeofAndStrlenstrlen(str) = 4sizeof(str) = 100。
sizeof和strlen的区别
博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户, 立即注册
sizeof和 strlen的ቤተ መጻሕፍቲ ባይዱ别
一、指代不同 1、sizeof：用于获取字符串的长度，是处理字符串的重要工具。 2、strlen：所作的是一个计数器的来工作。 二、规则不同 1、sizeof：可用于任何变量名、类型名或常量值，当用于变量名（不是数组名）或常量时，不需要用圆括号自。 2、strlen：从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结知束符'\0'为止，然后返回计数器值。 三、用法不同 1、sizeof：sizeof( type_name ); // sizeof( 类型 )；编译时起作用道，而不是运行时。 2、strlen：extern unsigned int strlen(char *s)；返回s的长度，不包括结束符NULL。
字符串的sizeof长度及strlen长度
字符串的sizeof长度及strlen长度在C/C++中，字符串是以零('\0')结尾的。
⽐如，对于下⾯的字符串："hello"在最后⼀个字符'd'后⾯，还有⼀个我们⾁眼看不见的'\0'字符，作为该字符串的结束符。
所以，"Hello"其在内存中的存储形式为：'H' 'e' 'l' 'l' 'o' '\0'最后有⼀个我们看不见的'\0'。
明⽩了字符串的结尾⽅式，那么如何计算字符串的长度呢？⽐如：例题1：char str1[]="12345678";char str2[]={'1','2','3','4','5','6','7','8'};char str3[]={'1','2','3','\0','5','6','7','8'};sizeof(str1)=?sizeof(str2)=?sizeof(str3)=?strlen(str1)=?strlen(str2)=?strlen(str3)=?分析：str1是⼀个字符数组，由字符串"12345678"进⾏初始化。
由于"12345678"含有⼀个结尾字符'\0'，所以str1数组共有9个字符。
因此sizeof(str1)=9。
str2也是⼀个字符数组，它的长度由'1','2','3','4','5','6','7','8'8个字符初始化，并没有指明零字符。
C++获取字符串长度的几个函数方式
C++获取字符串长度的⼏个函数⽅式C/C++ strlen(str)、str.length()、str.size()、sizeof(str)都可以求字符串长度。
其中str.length()、str.size()、sizeof(str)是⽤于求string类对象的成员函数strlen(str)是⽤于求字符数组的长度，其参数是char*。
补充知识：获取字符串长度的函数sizeof()、strlen()、length()、size()详解和区别在C++中计算长度的函数有四种，它们分别是sizeof() ，size()，strlen()，str.length()。
⼀. sizeof()和strlen()两者区别：1）sizeof操作符的结果类型是size_t，该类型保证能容纳实现所建⽴的最⼤对象的字节⼤⼩。
2）sizeof是运算符，strlen是函数。
3）sizeof可以⽤类型做参数，strlen只能⽤char*做参数，且必须是以''\0''结尾的。
4）sizeof在编译时期就计算出来，strlen在运⾏之后才能计算出来。
5）strlen计算字符串的具体长度（只能是字符串），不包括字符串结束符。
返回的是字符个数。
sizeof计算声明后所占的内存数（字节⼤⼩），不是实际长度。
举例：1）char* ss = "0123456789";sizeof(ss)为4，ss是指向字符串常量的字符指针，sizeof 获得的是指针所占的空间,则为4sizeof(*ss)为1，*ss是第⼀个char字符，则为12）char ss[] = "0123456789";sizeof(ss)为11,ss是数组，计算到'\0'位置，因此是(10+1)sizeof(*ss)为1,*ss是第⼀个字符3）char ss[100] = "0123456789";sizeof(ss)为100，ss表⽰在内存中预分配的⼤⼩，100*1strlen(ss)为10，它的内部实现⽤⼀个循环计算字符串的长度,直到'\0'为⽌。
C语言字符串长度（转）
C语⾔字符串长度（转）C语⾔字符串长度的计算是编程时常⽤到的，也是求职时必考的⼀项。
C语⾔本⾝不限制字符串的长度，因⽽程序必须扫描完整个字符串后才能确定字符串的长度。
在程序⾥，⼀般会⽤strlen()函数或sizeof来获取⼀个字符串的长度，但这2种⽅法获取的字符串的长度其实是不⼀样，我们⽤如下函数进⾏测试：1 #include<stdlib.h>2 #include<string.h>3 #include<stdio.h>4int main() {56char s1[20] = "hello world";7char s2[20] = {'h','e','l','l','0','','w','o','r','l','d','\0'};8char s3[] = "hello\0 world";9char s4[] = {'h','e','l','l','0','\0','','w','o','r','l','d','\0'};1011 printf("%d\t%d\t%d\t%d\n",strlen(s1),strlen(s2),strlen(s3),strlen(s4));12 printf("%d\t%d\t%d\t%d\n",sizeof(s1),sizeof(s2),sizeof(s3),sizeof(s4));13 }注意，该函数⾥⾯定义了4个字符串，基本数据都是“hello world",但需要注意的是，字符串s1和s2给定了字符串数组的⼤⼩为20，然后使⽤2种⽅式进⾏赋值；字符串s3和s4是s1和s2对⽐的字符串，区别就是s3和s4字符串中间插⼊了⼀个'\0'。
sizeof与strlen的区别
strlen函数与sizeof的区别，C语言strlen与sizeof 的区别详解strlen 是一个函数，它用来计算指定字符串str 的长度，但不包括结束字符（即null 字符）。
其原型如下面的代码所示：size_t strlen(char const* str);也正因为strlen 是一个函数，所以需要进行一次函数调用，调用示例如下面的代码所示：1.char sArr[]="ILOVEC";2./*用strlen()求长度*/3.printf("sArr的长度=%d\n",strlen(sArr));很显然，上面示例代码的运行结果为6（因为不包括结束字符null）。
这里需要特别注意的是，函数strlen 返回的是一个类型为size_t 的值，从而有可能让程序导致意想不到的结果，如下面的示例代码所示：1./*判断一*/2.if(strlen(x)>=strlen(y))3.{4.}5./*判断二*/6.if(strlen(x)-strlen(y)>=0)7.{8.}从表面上看，上面的两个判断表达式完全相等，但实际情况并非如此。
其中，判断表达式一没什么问题，程序也能够完全按照预想的那样工作；但判断表达式二的结果就不一样了，它将永远是真，这是为什么呢？原因很简单，因为函数strlen 的返回结果是size_t 类型（即无符号整型），而size_t 类型绝不可能是负的。
因此，语句“if(strlen(x)-strlen(y)>=0）”将永远为真。
同样，就算表达式中同时包含了有符号整数和无符号整数，还是有可能产生意想不到的结果，如下面的代码所示：1./*判断一*/2.if(strlen(x)>=5)3.{4.}5./*判断二*/6.if(strlen(x)-5>=0)7.{8.}很显然，判断表达式二的结果还是永远是真，其原因与上面相同。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
strlen(ss)= 10 >>>> 如果要获得这个字符串的长度，则一定要使 用 strlen
}
我们能常在用到 sizeof 和 strlen 的时候，通常是计算字符串数组的长 度 看了上面的详细解释，发现两者的使用还是有区别的，从这个例子可以 看得很清楚：
char str[20]="0123456789"; int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度，以结束 符 0x00 为字符串结束。 int b=sizeof(str); //而b=20; >>>> sizeof 计算的则是分配的数 组 str[20] 所占的内存空间的大小，不受里面存储的内容改变。
len_three << endl; 输出结果：23 and 4 and 1 点评：第一个输出结果23实际上每次运行可能不一样，这取决于
parr里面存了什么（从parr[0]开始知道遇到第一个NULL结束）；第二 个结果实际上本意是想计算parr所指向的动态内存空间的大小，但是事 与愿违，sizeof认为parr是个字符指针，因此返回的是该指针所占的空 间（指针的存储用的是长整型，所以为4）;第三个结果，由于*parr所 代表的是parr所指的地址空间存放的字符，所以长度为1。 ************
四、参考资料： 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。
小，不关心里面存了多少数据。strlen只关心存储的数据内容，不关心 空间的大小和类型。
eg2、char * parr = new char[10]; int len_one = strlen(parr); int len_two = sizeof(parr); int len_three = sizeof(*parr); cout << len_one << " and " << len_two << " and " <<
二、strlen strlen(...)是函数，要在运行时才能计算。参数必须是字符型指针
（char*）。当数组名作为参数传入时，实际上数组就退化成指针了。 它的功能是：返回字符串的长度。该字符串可能是自己定义的，也可
能是内存中随机的，该函数实际完成的功能是从代表该字符串的第一个 地址开始遍历，直到遇到结束符NULL。返回的长度大小不包括NULL。 *****************
三、举例： eg1、char arr[10] = "What?"; int len_one = strlen(arr); int len_two = sizeof(arr); cout << len_one << " and " << len_two << endl; 输出结果为：5 and 10 点评：sizeof返回定义arr数组时，编译器为其分配的数组空间大
大小。实际上，用sizeof来返回类型以及静态分配的对象、结构或数组 所占的空间，返回值跟对象、结构、数组所存储的内容没有关系。
具体而言，当参数分别如下时，sizeof返回的值表示的含义如下： 数组——编译时分配的数组空间大小； 指针——存储该指针所用的空间大小（存储该指针的地址的长度， 是长整型，应该为4）； 类型——该类型所占的空间大小； 对象——对象的实际占用空间大小； 函数——函数的返回类型所占的空间大小。函数的返回类型不能 是void。 **************
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 操作符不能返回动态地被分派了的数组或外部的数组的尺寸
Sizeof与Strlen的区别与联系
一、sizeof sizeof(...)是运算符，在头文件中typedef为unsigned int，其值在编
译时即计算好了，参数可以是数组、指针、类型、对象、函数等。 它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。 由于在编译时计算，因此sizeof不能用பைடு நூலகம்返回动态分配的内存空间的
上面是对静态数组处理的结果，如果是对指针，结果就不一样了
char* ss = "0123456789"; sizeof(ss) 结果 4 ＝＝＝》ss是指向字符串常量的字符指针，sizeof 获 得的是一个指针的之所占的空间,应该是
长整型的，所以是4 sizeof(*ss) 结果 1 ＝＝＝》*ss是第一个字符 其实就是获得了字符串的 第一位'0' 所占的内存空间，是char类
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);