strlen 订阅
strlen所作的是一个计数器的工作,它从内存的某个位置(可以是字符串开头,中间某个位置,甚至是某个不确定的内存区域)开始扫描,直到碰到第一个字符串结束符'\0'为止,然后返回计数器值(长度不包含'\0')。 [1] 展开全文
strlen所作的是一个计数器的工作,它从内存的某个位置(可以是字符串开头,中间某个位置,甚至是某个不确定的内存区域)开始扫描,直到碰到第一个字符串结束符'\0'为止,然后返回计数器值(长度不包含'\0')。 [1]
信息
返回值
给定字符串(不包括“\0”)长度
头文件
string.h(C)或cstring(C++)
格    式
strlen(字符指针表达式)
中文名
strlen
功    能
计算给定字符串的长度
实    质
C/C++语言函数
strlen函数原型
在Visual C++ 6.0或Dev-C++中,原型为,其中size_t实际上是unsigned int,在VC6.0或Dev-C++中可以看到这样的代码:头文件:string.h或cstring格式:strlen (字符指针表达式)功能:计算给定字符串的(unsigned int型)长度,不包括'\0'在内说明:返回s的长度,不包括结束符NULL。相关函数:
收起全文
精华内容
下载资源
问答
  • len 标准C库的函数的示例实现。 入门 本节介绍如何设置项目所需的构建环境。 该项目已经过 20.10上的GCC 10和Clang 11的C ++编译器测试。 使用以下命令至少安装这些编译器之一。 海湾合作委员会10 ...
  • 主要介绍了php常用字符串长度函数strlen()与mb_strlen()用法,结合实例形式分析了php字符串长度函数strlen()与mb_strlen()功能、用法及相关操作注意事项,需要的朋友可以参考下
  • 本文实例讲述了C++不使用变量求字符串长度strlen函数的实现方法。分享给大家供大家参考。具体实现方法如下: 1、strlen的源码实现: size_t strlen(const char *str) //strlen不做内存非法判断,如果是NULL,会...
  • 本文实例分析了php中strlen和mb_strlen用法。分享给大家供大家参考,具体如下: 首先看如下代码(文件编码utf8): <?php $utf8_string = "abcd我你他她它"; var_dump(strlen($utf8_string)); var_dump(mb_...
  • strlen

    千次阅读 2019-07-11 11:42:23
    strlen

    strlen计算长度

    strlen在计算长度时,一定要注意计算的字符串中是否含有\0字符(请注意,0和\0是有区别的,0代表数字,\0代表转义字符,值是48),比如你希望算0x1234056的长度,实际计算值strlen是7;如果是这类数据{‘1,’,‘2’,‘\0’, ‘3’},strlen计算出来就是2;这类数据{‘1,’,‘2’,’0’, ‘3’},strlen计算出来是4。
    注意:这里’\0’和’0’是有区别的,看ascii码对照表可以知道:
    在这里插入图片描述

    '\0’的十进制就是0,而’0’的十进制是48;

    另外,单说’\0’来说,它是一个字符,作为字符串结尾字符。它是一个字节大小,占8位。因为0x00是16进制,在内存中存放方式是:00000000,而在这8个0最后是一个‘\0’结束符,所以对于整个0x00来说,它在计算机内存中其实和’\0’的表示是一样的。所以在strlen到0x00最后一个0时便会结束,类似{0x1,0x02,0x00,0x03}得到的结果便是2。至于为什么数字0不会失败,因为数字0在内存中占4字节,32bit,而strlen在拷贝时是单字节拷贝,所以还遇不到0的最后一个结束符。

    展开全文
  • strlen函数原型:unsigned int strlen(const char *);返回的是字符串中第一个\0之前的字符个数。  1.strcat函数原型char* strcat(char* dest,const char* src); 进行字符串的拼接,将第二个字符串连接到第一个字符串...
  • 在PHP中,函数strlen()返回字符串的长度,strlen()函数返回字符串所占的字节长度,一个英文字母、数字、各种符号均占一个字节,它们的长度均为1
  • 在PHP中,strlen与mb_strlen是求字符串长度的函数,但是对于一些初学者来说,如果不看手册,也许不太清楚其中的区别
  • 在php中常见的计算字符串长度的函数有:strlen和mb_strlen.当字符全是英文字符的时候,两者是一样。这里主要比较一下,中英文混排的时候,两个计算结果。
  • Strlen

    千次阅读 2017-07-20 09:43:27
    strlen (C语言函数)  strlen所作的仅仅是一个计数器的工作,它从内存的某个位置(可以是字符串开头,中间某个位置,甚至是某个不确定的内存区域)开始扫描,直到碰到第一个字符串结束符'\0'为止,然后返回计数器...

    strlen C语言函数) 

    strlen所作的仅仅是一个计数器的工作,它从内存的某个位置(可以是字符串开头,中间某个位置,甚至是某个不确定的内存区域)开始扫描,直到碰到第一个字符串结束符'\0'为止,然后返回计数器值(长度不包含'\0')[1] 


    中文名

    strlen

    头文件

    string.h

        

    strlen 字符数组名)

        

    计算给定字符串的长度

        

    C语言函数

    目录




    函数原型

    编辑

    extern unsigned int strlen(char *s);

    Visual C++ 6.0中,原型为size_t strlen(const char *string); ,其中size_t实际上是unsigned int,在VC6.0中可以看到这样的代码:typedef unsigned int size_t;

    头文件string.h

    格式:strlen字符数组名)

    功能:计算给定字符串的(unsigned int型)长度,不包括'\0'在内

    说明:返回s的长度,不包括结束符NULL

    相关函数:

    TCHAR.H routine _UNICODE & _MBCS not defined_MBCS defined_UNICODE defined_tcslen

    strlen

    strlen

    wcslen

     

    _tcsclen

    strlen

    _mbslen

    wcslen




    程序举例

    编辑

    举例1:(在Visual C++6.0中运行通过)

    1

    2

    3

    4

    5

    6

    7

    8

    9

    #include<string.h>

    #include<stdio.h>

    int main(void)

    {

        char*s="GoldenGlobalView";

        printf("%s has %d chars",s,strlen(s));

        getchar();

        return 0;

    }




    区别sizeof

    编辑

    strlen(char*)函数求的是字符串的实际长度,它求得方法是从开始到遇到第一个'\0',如果你只定义没有给它赋初值,这个结果是不定的,它会从aa首地址一直找下去,直到遇到'\0'停止。

    char aa[10];cout<<strlen(aa)<<endl; //结果是不定的

    char aa[10]={'\0'}; cout<<strlen(aa)<<endl; //结果为0

    char aa[10]="jun"; cout<<strlen(aa)<<endl; //结果为3(此处不完全正确,结果可能是不定的,如果编译器将其他的非零字符串放在aa[10]的内存地址后,strlen结果还是不定的,MSP430IAR编译测试过)(但是在vc6中结果为3,编译器会在处自动添上\0。)

    char aa[5]="hello";cout<<strlen(aa)<<endl; //结果5(此处不完全正确,理由如上,因为实际内存中,hello后面不一定是空(即\0))(还应视编译器而定)

    sizeof()返回的是变量声明后所占的内存数,不是实际长度,此外sizeof不是函数,仅仅是一个取字节运算符,strlen是函数。

    sizeof(aa) 返回10

    int a[10]; sizeof(a) 返回40 (根据语言int c/c++由编译器决定是两个或四个 java是四个)

    sizeof操作符的结果类型是size_t,它在头文件中typedefunsigned int类型。

    该类型保证能容纳实现所建立的最大对象的字节大小。

    sizeof是取字节运算符(关键字),strlen是函数。

    sizeof可以用类型做参数,strlen只能用char*做参数,且必须是以''\0''结尾的。

    sizeof还可以用函数做参数,比如:

    short f();

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

    输出的结果是sizeof(short),即2

    ⒋数组做sizeof的参数不退化,传递给strlen就退化为指针了。

    ⒌大部分编译程序 在编译的时候就把sizeof计算过了是类型或是变量的长度。这就是sizeof(x)可以用来定义数组维数的原因

    char str[20]="0123456789";

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

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

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

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

    ⒏当适用了于一个结构类型时或变量, sizeof返回实际的大小,

    当适用一静态地空间数组, sizeof归还全部数组的尺寸。

    sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸

    ⒐数组作为参数传给函数时传的是指针而不是数组,传递的是数组的首地址,

    如:

    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 的时候,通常是计算字符串数组的长度

    看了上面的详细解释,发现两者的使用还是有区别的,从这个例子可以看得很清楚:

    char str[20]="0123456789";

    int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度,以结束符 0x00 为字符串结束。

    int b=sizeof(str); //b=20; >>>> sizeof计算的则是分配的数组 str[20]所占的内存空间的大小,不受里面存储的内容改变。

    上面是对静态数组处理的结果,如果是对指针,结果就不一样了

    char* ss = "0123456789";

    sizeof(ss) 结果 4>>>>ss是指向字符串常量的字符指针,sizeof获得的是一个指针的值所占的空间,应该是长整型的,所以是4

    sizeof(*ss) 结果 1>>>> *ss是第一个字符其实就是获得了字符串的第一位'0' 所占的内存空间,是char类型的,占了 1

    strlen(ss)= 10 >>>> 如果要获得这个字符串的长度,则一定要使用 strlen

    sizeof返回对象所占用的字节大小. //正确

    strlen返回字符个数. //正确

    在使用strlen时,有一个很特别的情况,就是数组名到指针蜕变,

    char Array[3] = {'0'};

    sizeof(Array) == 3;

    char *p = Array;

    strlen(p) == 1;//sizeof(p)结果为4

    在传递一个数组名到一个函数中时,它会完全退化为一个指针

    ----------------------------------------------------------

    看完以上你是否很清楚sizeofstrlen的区别了呢?还不明白的话,我们看下面几个例子:




    第一个例子

    char* ss = "0123456789";

    sizeof( ss) 结果 4 ===ss是指向字符串常量的字符指针

    sizeof(*ss) 结果 1 ===*ss是第一个字符

    大部分编译程序 在编译的时候就把sizeof计算过了是类型或是变量的长度

    这就是sizeof(x)可以用来定义数组维数的原因

    char str[20]="0123456789";

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

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

    char ss[] = "0123456789";

    sizeof(ss) 结果 11 ===ss是数组,计算到\0位置,因此是10+1

    sizeof(*ss) 结果 1 ===*ss是第一个字符

    char ss[100] = "0123456789";

    sizeof(ss) 结果是100 ===ss表示在内存中的大小 100×1

    strlen(ss) 结果是10 ===strlen是个函数,内部实现是用一个循环计算到\0之前为止

    int ss[100] = "0123456789";

    sizeof(ss) 结果 400 ===ss表示在内存中的大小 100×4

    strlen(ss) 错误 ===strlen的参数只能是char*且必须是以'\0'结尾的

    char q[]="abc";

    char p[]="a\n";

    sizeof(q),sizeof(p),strlen(q),strlen(p);

    结果是 4 3 3 2




    第二个例子

    class X{ int i; int j; char k;};X x;

    cout<<sizeof(X)<<endl; 结果 12 ===》内存补齐

    cout<<sizeof(x)<<endl; 结果 12 同上




    第三个例子

    char szPath[MAX_PATH]

    如果在函数内这样定义,那么sizeof(szPath)将会是MAX_PATH,但是将szPath作为虚参声明时(void fun(char szPath[MAX_PATH])),sizeof(szPath)却会是4(指针大小)

    还有一位网友的说明也很好:

    其实理解 sizeof 只需要抓住一个要点:栈

    程序存储分布有三个区域:栈、静态和动态。能够从代码直接操作的对象,包括任何类型的变量、指针,都是在栈上的;动态和静态存储区是靠栈上的指针来间接操作的。sizeof操作符,计算的是对象在栈上的投影体积;记住这个就很多东西都很清楚了。

    char const * static_string = "Hello";

    sizeof(static_string) sizeof 一个指针,所以在 32bit system 4

    char stack_string[] = "Hello";

    sizeof(stack_string) sizeof 一个数组,所以是 6 * sizeof(char)

    char * string = new char[6];

    strncpy(string,"Hello",6");

    sizeof(string) sizeof 一个指针,所以还是 4。和第一个不同的是,这个指针指向了动态存储区而不是静态存储区。

    不管指针指向的内容在什么地方,sizeof得到的都是指针的栈大小

    C++ 中对引用的处理比较特殊;sizeof一个引用得到的结果是 sizeof 一个被引用的对象的大小;所以

    struct O{ int a,b,c,d,e,f,g,h;};int main(){ O & r = *new O; cout << sizeof(O) << endl; // 32 cout << sizeof r << endl; //也是 32 system("PAUSE");}

    r 引用的是整个的 O对象而不是指向 O 的指针,所以 sizeof r的结果和 sizeof O 完全相同。

    自定义函数实现strlen()函数的功能

    下面几种实现strlen函数的源代码大家参考

    1

    1

    2

    3

    4

    5

    6

    7

    8

    9

    #include<stdio.h>

    #include<assert.h>

    typedefunsignedintu_int;

    u_intMystrlen(constchar*str){

    u_inti;

    assert(str!=NULL);

    for(i=0;str[i]!='\0';i++);

    returni;

    }

    2

    1

    2

    3

    4

    5

    6

    7

    intstrlen(constchar*str){

    assert(str!=NULL);

    intlen=0;

    while((*str++)!='\0')

    len++;

    returnlen;

    }

    3

    1

    2

    3

    4

    5

    6

    intstrlen(constchar*str){

    assert(str);

    constchar*p=str;

    while(*p++!=NULL);

    returnp-str-1;

    }

    4

    1

    2

    3

    4

    5

    6

    7

    intstrlen(constchar*str){

    assert(str);

    if(*str==NULL)

    return0;

    else

    return1+strlen(++str));

    }

    5

    1

    2

    3

    4

    5

    6

    /***strlen-Findthelengthofastring*@s:Thestringtobesized*/

    size_tstrlen(constchar*s){

    constchar*sc;

    for(sc=s;*sc!='\0';++sc)/*nothing*/;

    returnsc-s;

    }

    以上各种实现的方式都是大同小异的,有的用的是变量,有的用的是指针

    其中,最后一个用的是递归的方式。其实,在实现库函数的时候,是规定不可以

    调用其他的库函数的,这里只是给大家一个方法,可以不用变量就可以实现strlen



    展开全文
  • 在php中常见的计算字符串长度的函数有:strlen和mb_strlen,下面是对这两个函数的比较说明(编码方式UTF8)
  • strlen和mb_strlen的区别,但是对于一些初学者来说,如果不看手册,也许不太清楚其中的区别,下面与大家分享下两者之间的区别
  • 使用AVX2指令集实现的strlen函数,一般情况下较新的CPU都支持avx2指令集,使用avx2指令集可以加快程序的运行速度
  • c语言本身有strlen函数,这个是利用递归自己写的
  • 在PHP中,函数strlen()返回字符串的长度,strlen()函数返回字符串所占的字节长度,一个英文字母、数字、各种符号均占一个字节,它们的长度均为1
  • 下面小编就为大家带来一篇浅谈C语言中strcpy,strcmp,strlen,strcat函数原型。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • sizeof和strlen的区别

    2017-12-19 18:35:49
    操作符sizeof和函数strlen的区别,代码已经过测试,可以直接使用!
  • C语言sizeof与strlen详解(附大量笔试题题解过程)

    千次阅读 多人点赞 2021-09-10 11:51:47
    二.strlen()详解 strlen()的模拟实现: 法1:计数器 法2:指针-指针 法3:递归 三.strlen与sizeof的区别 四.笔试题 1.整形数组int a[] = {1,2,3,4} strlen()相关题目 sizeof()相关题目 2.字符数组-...

    前言:相信很多初学者都对被sizeof和strlen搞得晕晕的,相信看完这篇文章,你对这二者的认识将提升一个档次!已经了解sizeof和strlen的大佬们就当复习吧,哈哈哈~


    目录

    一.sizeof()详解

    二.strlen()详解

    strlen()的模拟实现:

    法1:计数器

    法2:指针-指针

    法3:递归

    三.strlen与sizeof的区别

    四.笔试题

    1.整形数组int a[] = {1,2,3,4}

    strlen()相关题目

    sizeof()相关题目

    2.字符数组-char arr[] = {'a','b','c','d','e','f'}

    strlen()相关题目

    sizeof()相关题目

    3.字符数组-char arr[] = “abcdef”

    strlen()相关题目

    sizeof()相关题目

    4.指针指向的常量字符串-char *p = "abcdef"

    strlen()相关题目

    sizeof()相关题目

    5.二维数组-int a[3][4]

    sizeof()相关题目

    五.总结:


    一.sizeof()详解

    1.sizeof()作用:计算变量/类型所占内存大小,单位是字节

    int a = 10;
    int b =sizeof(a);    //a为int类型,大小为4个字节
    int c = sizeof(int);   //4

    2.sizeof是操作符,不是函数!!! 

    sizeof 变量 或者 sizeof(变量)都可以 

    sizeof(类型)可以      sizeof 类型是错误的

    int main()
    {
    	int a, b, c, d;
    	a = sizeof(a);
    	b = sizeof a;
    	c = sizeof(int);
    	//d = sizeof int;	//err
    	printf("%d %d %d\n", a, b, c);    // 4 4 4
    	return 0;
    }

    3.sizeof ()内部的表达式不参与真实运算!这点很重要!其运算值在编译时就计算好了 

    int main()
    {
    	int a = 10;
    	int b = sizeof(a = a + 1);
    	printf("%d %d \n", a, b);    // 10 4
    	return 0;
    }

    sizeof内部即使写的是赋值表达式也不会去真实的运算,sizeof在计算的时候只看操作数的类型,不会访问对应的空间 


    4.sizeof()与数组名的关系

    sizeof(数组名):此时的数组名代表的是整个数组

    &数组名:此时的数组名代表的也是整个数组 

    其他情况,数组名代表的是首元素地址

    int arr[10];
    a = sizeof(arr);    //计算的是整个数组的大小 4*10 = 10
    b = sizeof(&arr);   //取出整个数组的地址,是地址(指针),4/8

    5.sizeof()返回类型造成的坑

    int i ;	//全局变量未初始化系统默认为0
    int main()
    {
        i--;	//i变成-1
        if(i > sizeof(i))
        {
            printf(">\n");
        }
        else
        {
            printf("<\n");
        }
        return 0;
    }

     打印结果: >

    注意:sizeof(i)和i比较时,sizeof返回类型为size_t 而i的类型为int,最终是用size_t比较,对于-1的补码为:全1序列,如果看成是无符号数的话,对于的值比sizeof(i) = 4大


    二.strlen()

    strlen():求字符串长度的库函数,遇到\0即停止计算。需要引用#include<string.h>头文件,注意返回类型为:size_t(unsigned int 无符号整型),

    函数原型:


    strlen()的模拟实现:

    法1:计数器

    size_t my_strlen(const char* str)
    {
    	size_t count = 0;
    	while (*str != '\0')
    	{
    		count++;
    		str++;
    	}
    	return count;
    }

    法2:指针-指针

    指针-指针得到的是二者之间元素的个数。所以只要一个指针指向字符串首字符,一个指针指向\0,二者相减就是字符串长度

    size_t my_strlen2(const char* str)
    {
    	char* start = str;
    	char* end = str;
    	while (*end != '\0')
    	{
    		end++;
    	}
    	return end - start;
    }

    法3:递归

    //法3:递归
    size_t my_strlen3(const char* str)
    {
    	//如果不是\0就+1(本身指向字符),然后递归下一个字符
    	if (*str != '\0')
    		return 1 + my_strlen3(str + 1);
    	//遇到\0即返回0
    	else
    		return 0;
    }

    strlen()返回参数size_t造成的坑点:

    int main()
    {
    	char* p1 = "abcd";
    	char* p2 = "abcde";
    
    
    	if (strlen(p1) - strlen(p2)>0)
    	{
    		printf("p1>p2");
    	}
    	else
    	{
    		printf("p1<p2");
    	}
    	return 0;
    }

    上述代码打印结果:p1>p2

    strlen(p1) 结果为4  strlen(p2):结果为5  二者的类型都为size_t   无符号整形

    二者相减得到-1,也被认为是无符号整形,对应的值>0 


    三.strlen与sizeof的区别

    共同点:返回类型都是size_t

    不同点:sizeof()是操作符计算的是变量/类型所占空间的大小,单位是字节,\0也算进空间

                  strlen()是库函数,计算的是字符串长度,不计算\0

    int main()
    {
    	char arr1[] = { 'a','b','c' };
    	int ret1 = strlen(arr1);
    	int ret2 = sizeof(arr1);
    	printf("%d %d\n", ret1,ret2);    //随机值    3
    //arr1并没放入\0,strlen()向后直到找到\0才停止,所以是随机值  而arr1本身数组元素个数为3,根据后面初始化的内容确定了数组的大小,sizeof:3*1 = 3
    
    	char arr[] = "abcdef";
    	int ret3 = strlen(arr);
    	int ret4 = sizeof(arr);
    	printf("%d %d\n", ret3, ret4);    //6 7
    //arr大小为7,含\0  strlen不算\0
    	return 0;
    }

    四.笔试题

    1.整形数组int a[] = {1,2,3,4}

    sizeof()相关题目

    int main()
    {
    	int a[] = { 1,2,3,4 };
    	printf("%d\n", sizeof(a));//数组名a单独放在sizeof内部,数组名表示整个数组,计算的是整个数组的大小
    	printf("%d\n", sizeof(a + 0));//a表示首元素的地址,a+0还是首元素的地址,地址的大小是4/8字节
    	printf("%d\n", sizeof(*a));   //a表示首元素的地址,*a 就是首元素 ==> a[0] ,大小就是4
    	//*a <==> *(a+0) <==> a[0]
    	printf("%d\n", sizeof(a + 1));//a表示首元素的地址,a+1是第二个元素的地址,大小就是4/8
    	printf("%d\n", sizeof(a[1])); //a[1] 就是第二个元素 - 4
    	printf("%d\n", sizeof(&a));   //&a - 数组的地址 - 4/8 - int(*)[4]
    	printf("%d\n", sizeof(*&a));  //*&a - &a是数组的地址,对数组的地址解引用拿到的是数组,所以大小时候16
    	//相当于printf("%d\n", sizeof(a));//16
    
    	printf("%d\n", sizeof(&a + 1));//4/8 &a是数组的地址,&a+1 是数组的地址+1,跳过整个数组,虽然跳过了数组,
    	//还是地址  4/8
    	printf("%d\n", sizeof(&a[0]));//4/8
    	printf("%d\n", sizeof(&a[0] + 1));//第二个元素的地址 4/8
    	return 0;
    }

    2.字符数组-char arr[] = {'a','b','c','d','e','f'}

    strlen()相关题目

    //字符数组
    char arr[] = {'a','b','c','d','e','f'};
    //arr中是没有放\0的,而strlen()求长度是找到\0才停止
    
    printf("%d\n", strlen(arr));//从arr位置(首元素地址)向后求长度,随机值
    
    printf("%d\n", strlen(arr+0));//从arr位置(首元素地址)向后求长度,随机值
    
    //printf("%d\n", strlen(*arr));//arr是首元素地址,*arr是字符‘a’-ascii-97,strlen把字符a对应的ascii码值97作为地址向后计数,非法访问!err
    
    //printf("%d\n", strlen(arr[1]));//strlen把字符b对应的ascii码值98作为地址向后计数,非法访问!err
    
    printf("%d\n", strlen(&arr));//&arr和arr地址值相同,都是首元素地址,但是意义不一样
    //&arr传给strlen  &arr类型:数组指针 char(*p)[6] 而strlen接收的类型为char*,不兼容,但是问题不大
    //从数组首元素位置向后计数,随机值
    
    printf("%d\n", strlen(&arr+1));//跳过整个数组后,向后计数,随机值-6
    //原因:内存空间连续,同时找到\0停止,但是strlen(arr)和strlen(&arr)得到的随机值比第二个多6个字符abcdef
    
    printf("%d\n", strlen(&arr[0]+1));//从字符b位置向后计数,随机数-1

    sizeof()相关题目

    //字符数组
    char arr[] = {'a','b','c','d','e','f'};
    //&arr的类型:数组指针: char(*)[6]
    
    printf("%d\n", sizeof(arr));//数组名单独放在sizeof内部,计算的是整个数组的大小,元素个数为6个(不含\0),类型为char 所以大小为6
    
    printf("%d\n", sizeof(arr+0));//此处的arr代表的是首元素地址,arr+0仍是首元素地址char*,地址(指针)大小是4/8
    
    printf("%d\n", sizeof(*arr));//此处的arr代表的是首元素地址,*arr即为数组首元素,即为字符‘a’  大小为1
    
    printf("%d\n", sizeof(arr[1]));//arr[1]->字符‘b’,大小为1
    
    printf("%d\n", sizeof(&arr));//取出整个数组的地址,还是地址,地址的大小就是4/8  
    
    printf("%d\n", sizeof(&arr+1));//取出数组arr的地址+1,跳过一个数组,还是地址,地址的大小为:4/8
    
    printf("%d\n", sizeof(&arr[0]+1));//数组第二个元素的地址,4/8

    3.字符数组-char arr[] = “abcdef”

    strlen()相关题目

    char arr[] = "abcdef";
    //此时数组arr中存放了\0  strlen求长度,遇到\0即停止计数
    
    printf("%d\n", strlen(arr));//从arr位置开始向后计数,遇到\0即停,长度为6
    
    printf("%d\n", strlen(arr+0));///从arr位置开始向后计数,遇到\0即停,长度为6
    
    //printf("%d\n", strlen(*arr));//arr是首元素地址,*arr是字符‘a’对应ascii值为97,strlen把字符a对应的ascii码值97作为地址向后计数,非法访问!err
    
    //printf("%d\n", strlen(arr[1]));///arr[1]:‘b’对应ascii值为98,strlen把字符b对应的ascii码值98作为地址向后计数,非法访问!err
    
    printf("%d\n", strlen(&arr));&arr和arr地址值相同,都是首元素地址,但是意义不一样
    //&arr传给strlen  &arr类型:数组指针 char(*p)[6] 而strlen接收的类型为char*,不兼容,但是问题不大
    //从数组首元素位置向后计数,值为 6
    
    printf("%d\n", strlen(&arr+1));//跳过整个数组后,向后计数,未知值
    
    printf("%d\n", strlen(&arr[0]+1));//从b未知向后计数,长度为5

    sizeof()相关题目

    char arr[] = "abcdef";
    //此时的arr数组里面是放了\0的
    
    printf("%d\n", sizeof(arr));//数组名单独放在sizeof内部,计算的是整个数组的大小,\0也算进去,大小为7
    
    printf("%d\n", sizeof(arr+0));//此时的数组名是首元素地址,地址(指针)大小:4/8
    
    printf("%d\n", sizeof(*arr));//此时的数组名是首元素地址,*arr即为首元素,字符a->char类型,大小为1
    
    printf("%d\n", sizeof(arr[1]));//arr[1]:字符'b',大小为1
    
    printf("%d\n", sizeof(&arr));//取出数组的地址,还是地址,大小为4/8
    
    printf("%d\n", sizeof(&arr+1));//取出数组的地址+1,跳过整个数组,还是地址:4/8
    
    printf("%d\n", sizeof(&arr[0]+1));//取出第一个元素的地址+1,跳过一个元素,即为第二个元素的地址,4/8

    4.指针指向的常量字符串-char *p = "abcdef"

    strlen()相关题目

    const char* p = "abcdef";
    //p存放的是字符a的地址,
    //p+1:字符b的地址
    
    printf("%d\n", strlen(p));//p存放的是字符a的地址,即从字符a的地址向后计数,长度为6
    
    printf("%d\n", strlen(p+1));//从字符b的地址向后计数,长度为5
    
    //printf("%d\n", strlen(*p));//*p ->字符‘a’  即以字符a的ascii码值97为地址向后计数,非法访问,err
    
    //printf("%d\n", strlen(p[0]));//p[0] ->字符‘a’  即以字符a的ascii码值97为地址向后计数,非法访问,err
    
    printf("%d\n", strlen(&p));//&p取出的是p变量的地址,即以p变量的地址(16进制)向后计数,  随机值
    
    printf("%d\n", strlen(&p+1));//&p取出的是p变量的地址,&p+1,跳过p变量,即从p变量之后的位置向后访问  随机值
    
    printf("%d\n", strlen(&p[0]+1));//&p[0]==>相当于&*(p+0)-->相当于sizeof(p),p存中存放的是字符a的地址,+1,即为字符b的地址,从字符b位置向后访问,  长度为5
    // p[0] :字符a  
    //&p[0]:字符a的地址 
    //&p[0] +1:字符b的地址
    
    //注意上面两个随机值没有必然关系,因为strlen(&p)是以p地址对应的16进制向后访问,值为未知数,有可能提前遇到\0结束了

    sizeof()相关题目

    //因为指针指向的是常量字符串,不可以被修改
    //所以可以用const修饰
    //char* p = "abcdef";
    const char * p ="abcdef";
    //p存放的是字符a的地址
    
    printf("%d\n", sizeof(p));//p是指针,指向字符a,大小为4/8
    
    printf("%d\n", sizeof(p+1));//p+1,指向的是字符b,指针,大小为4/8
    
    printf("%d\n", sizeof(*p));//p存放的是字符a的地址,*p:即为字符a,大小为1
    
    printf("%d\n", sizeof(p[0]));//p[0]->字符a ,大小为1
    
    printf("%d\n", sizeof(&p));//取出p变量的地址,仍是地址,大小为4/8
    
    printf("%d\n", sizeof(&p+1));//取出p变量的地址+1,跳过p变量,但仍是地址,大小为4/8
    
    printf("%d\n", sizeof(&p[0]+1));//&p[0]相当于&*(p+0),&和*抵消,&p[0]:字符a的地址,+1:字符b的地址,大小为4/8

    5.二维数组-int a[3][4]

    内存布局

    实际内存结构
    想象结构

    sizeof()相关题目

    //二维数组
    int a[3][4] = {0};
    
    printf("%d\n",sizeof(a));//数组名单独放在sizeof内部,计算的是整个数组的大小, 数组元素为12个,每一个元素大小为4个字节,12*4=48
    
    printf("%d\n",sizeof(a[0][0]));//计算的是数组第有一行第一个元素的大小,int类型,大小为4
    
    printf("%d\n",sizeof(a[0]));//a[0]==>*(a+0)==>数组名是首元素地址,即为第一行的地址,解引用第一行的地址,就是第一行,所以计算的是第一行元素的大小 4*4=16
    //a[0] : 二维数组的第一行
    
    printf("%d\n",sizeof(a[0]+1));//a[0]:第一行的数组名,代表第一行第一个元素的地址,a[0]+1::跳过一个元素,即为第一行第二个元素地址,大小为4/8  
    //注意:a[0] + 1 :不是第二行,a[0]是第一行的数组名,首元素地址,即为第一行第一个元素地址,a[0]+1:跳过一个元素   a+1:a为数组名,首元素地址,第一行的地址,a+1,跳过一行,二维数组第二行
    
    printf("%d\n",sizeof(*(a[0]+1)));//由上可得:a[0]+1:第一行第二个元素地址, *(a[0]+1):即为第一行第二个元素 int类型 大小为4
    
    printf("%d\n",sizeof(a+1));//a为二维数组的数组名->首元素地址,e二维数组第一行的地址,+1,跳过一行,即为第二行的地址->地址,大小为4/8
    
    printf("%d\n",sizeof(*(a+1)));//由上,a+1是第二行的地址,*(a+1)即为第二行,大小为4*4 = 16
    
    printf("%d\n",sizeof(&a[0]+1));//a[0]是第一行的数组名,&a[0]就是第一行的地址,(相当于是,数组名和取地址数组名的关系,二二者地址值相同,但是含义不同),&a[0]+1:跳过第一行,即为第二行地址,地址:4/8
    
    printf("%d\n",sizeof(*(&a[0]+1)));//由上:(&a[0]+1):第二行地址,解引用就是第二行,大小为4*4 = 16
    
    printf("%d\n",sizeof(*a));//二维数组数组名是首元素地址,即为第一行的地址,解引用就是第一行, 大小为4* 4  = 16
    
    printf("%d\n",sizeof(a[3]));//a[3]假设存在,就是第四行的数组名,sizeof(a[3])相当于数组名单独放在sizeof内部,计算的是第四行的大小, 4*4 = 16
    
    //sizeof内部的表达式不参与运算,即不会真的去访问a[3]的空间,所以不出错,它只看一下第四行的类型,并没有真正去访问第四行的内容,

    五.总结:

    strlen()和sizeof()坑点挺多的,大家认真学习!一起加油哈哈哈!

    如果感觉对你有帮助的,欢迎点个赞评论一下呀!


    展开全文
  • 在php中常见的计算字符串长度的函数有:strlen和mb_strlen.当字符全是英文字符的时候,两者是一样。这里主要比较一下,中英文混排的时候,两个计算结果。 先来看一个例子: 复制代码 代码如下: <?php  //测试时...
  • strlen函数的实现 以及出现的问题

    千次阅读 2018-03-09 01:33:44
    strlen函数的实现 size_t strlen(const char *string) //size_t是无符号整形 #include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;assert.h&amp;amp;gt; int my_strlen(const char...

    折半查找法

    strlen函数的实现

    size_t strlen(const char *string) //size_t是无符号整形
    #include <stdio.h>
    #include <assert.h>
    
    int my_strlen(const char *str)  //const在这里修饰是一大亮点 因为strlen函数只需计算字符串的长度,
    {                               //无需更改,所以加上const修饰,不能随意改变
        int count = 0;
        assert(str != NULL);    // assert()在这里是第二亮点,断言的作用,判断指针是否为空指针
        while(*str != '\0')
        {
           count++;
           str++;
        }
        return count;
    }
    int main()
    {
        char *p = "abcdef";
        int ch = my_strlen(p);
        printf("%d\n",ch);
        return 0;
    }
    

    strlen函数出现的一些问题

    //实现strlen函数是设定返回值为整形和无符号整形
    //下面是strlen函数返回无符号整数的缺点
    #include <stdio.h>
    #include <string.h>
    
    int main()
    {
        const char* str1 = "abcdef";
        const char* str2 = "abc";
        if(strlen(str2)-strlen(str1)>0)//strlen返回的是一个无符号数
        {                              //一个无符号数减去无符号数,结果也是无符号数,显然if括号里面不等于零,只能大于零
            printf("str2>str1\n");     //输出的是这个3-6
        }
        else
        {
           printf("str2<=str1\n");
        }
        return 0;
    }
         //结果输出的是str2>str1,显然是错误的,这就是返回无符号整数的确定
    
    展开全文
  • strlen函数

    千次阅读 2021-05-19 20:37:05
    C语言提供了strlen()函数,用于求字符串的长度。函数定义如下: int strlen (const char *s); 包含的头文件是: #include <string.h> 该函数就是求参数 s 指向字符串的长度。在介绍“数组”的这一章节中...
  • C/C++中strlen的用法

    万次阅读 多人点赞 2020-05-05 10:40:30
    strlen strlen所作的仅仅是一个计数器的工作,它从内存的某个位置(可以是字符串开头,中间某个位置,甚至是某个不确定的内存区域)开始扫描,直到碰到第一个字符串结束符’\0’为止,然后返回计数器值。 原型 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 560,044
精华内容 224,017
关键字:

strlen