精华内容
下载资源
问答
  • C语言:字符串数组与字符串指针数组

    万次阅读 多人点赞 2019-04-27 21:46:19
    1,首先,不论是局部,静态还是全局数组都必须在定义的时候初始化,否则就得通过其他方式,eg 循环操作,字符串处理...半天才发现应该用字符串指针数组 3,那么问题来了,字符串数组和字符串指针数组有什么区别 ...

    1,首先,不论是局部,静态还是全局数组都必须在定义的时候初始化,否则就得通过其他方式,eg 循环操作,字符串处理函数strcpy()

    2,附以下代码: 主要完成将”I am from china ”倒置为”china from am I”,

    最开始编写时,将str定义为字符串数组,怎么都出不来结果。半天才发现应该用字符串指针数组

    3,那么问题来了,字符串数组和字符串指针数组有什么区别

    举个例子  char a[] = "hello";   //字符串数组,存放的是字符

                    char *b[] = {"hello", "world"};//字符串指针数组,存放的是指针即元素地址,指针指向其中的元素

    字符数组初始化  char a[10] ="hello";//字符串以'\0'结尾,这种方式系统会自动在数组未填值的地方添加'\0'

                               char b[] = {'h', 'e' , 'l', 'l', '\0'};//类似于初始化整型数组,必须要手动在后面添加'\0'

    所以当我 这样定义时char a[] = {"hello", "world"};,报错str中有多余的元素。

     

    详细说明:
         假定字符串数据中也以NUL结束字符串    

          char  arr1[10][100];

          char *arr2[10];

        内存: arr1是个字符串数组,分配内存 10 * 100 = 1000 个字节。
                  arr2是个字符串指针数组,分配内存 10 * 8 = 80 个字节。

      标识符: arr1是个该数组第一个指向 100 个char型数据内存的指针。
                    形象的理解,arr1是一篇文章(共10行)中的     第一行的首地址。
                    arr2是个该数组第一个指向  1  个char型数据(8字节)内存的指针。
                    形象的理解,arr2是一篇文章(共10行)中的第一行的     首字符地址。

    元素访问: 
            
            a.  arr1[4][0];
                 *arr2[4];
                它们都是用于表示访问各自数组中第4行的首字符。

            b.  arr1[4]
                 arr2[4]
                它们都是用于表达第4行字符串。
                arr1[4]是字符指针常量,arr2[4]是字符指针变量。

            c.  char (*parr1)[100];
                 char **parr2;
                 parr1 = arr1 + 4;
                 parr2 = arr2 + 4;
                定义了两个变量,分别接收了两个数组的第4行的数据。
                parr1是指向第4行拥有100个字符的一维数组。
                parr2定义一个指向第4列的一个指针。

            d.  char *str1, *str2, *str2, *str4;
                 str1 = arr1[4];
                 arr1[4]它就是arr1第4行这个有100个字符的一维数组名,是该数组首元素的指针常量。
                 str2 = *( arr1 + 4 )
                 arr1+4是指向arr1第4行字符的指针,进行间接访问后,得到第4行字符这个一维数组的数组名。
                 str3 = arr2[4];
                 arr2[4]是arr2的第4个元素,该元素是指向一个字符串的首元素指针。
                 str3 = *( arr2 + 4 )
                 arr2+4是指向arr2第4个元素的指针,进行间接访问后,得到第4个元素,该元素是一个指向一个字符串首元素的指针。

    字符串数组与字符串指针的共同点:
           arr1[4]、*( arr1 + 4 ) 字符指针常量。
           arr2[4]、*( arr2 + 4 ) 字符指针变量。
           它们都是字符指针,只不过一个可以修改指针值,一个不能修改指针值。
           指针变量需要初始化,指针常量在定义时已经完成了初始化。
           若字符串数组中的数据也以NUL结尾,那么这两种指针都可以用字符串标准库函数的实参(因为这些函数都不会改变指针值)。

     

    三种方法:

    1.在C语言中,是将字符串作为字符数组来处理的,字符串是逐个存放到数组元素中的,例如用一个一维的字符数组存放字符串"I am a boy.",如下代码:

    char c[12] = {'I','a','m','a','b','o','y','.'};
    这个字符串的实际长度是11,数组长度是12,实际工作中,人们关心的往往是字符串的有效长度而不是字符串的数组长度,例如要打印字符串,这是就要知道字符串的实际长度。平时常使用下面三种方式来测定字符串的实际长度:
    (1)在串值后面加一个不计入长度的结束标记字符,比如'\0'来表示串值的终结

    初始化一个字符串的方法如下,在最后添加'\0'

    char str[] = {'I','a','m','h','a','p','p','y','\0'};
    也可以直接使用字符串常量初始化字符数组(系统自动加上'\0'),这种方法符合人们的习惯。

    char str[] = "I am happy";
    或者
    char str[] = {"I am happy"};
    注意:不能使用下面的赋值方式:
    char str[20];
    str = "I am happy";
    但可以用字符指针指向这个字符串:
    char *str;
    str = "I love China";


    (2)将实际串长度值保存在数组0的下标下

    #define MAXSIZE 20                        //数组的长度
    typdef char String[MAXSIZE+1];
    初始化字符串的方法:

    String t;
    StrAssign(t,"I am happy");                
    int StrAssign(String T,char *chars)  
    {
        T[0] = strlen(chars);                //下标为0存放数组长度
        for(i=1;i<=strlen(chars);i++)        //下标位置从1开始存放数据
        {
            T[i] = *(chars+i-1);
        }
         return 1;
    }
    (3)使用结构体类型(自定义类型)

    #define MAXSIZE 20
    typedef struct{
        char ch[MAXSIZE];
        int len;                
    }String;
    其中:MAXSIZE表示串的最大长度,ch是存储字符串的一维数组,len是字符串的长度
    初始化函数示例:

     String t;
     StrAssign(&t,"I am happy");
    int StrAssign(String *t,char *chars)
    {
        int i;
        if(strlen(chars)>MAXSIZE+1)        //字符串的长度大于数组的长度,操作失败,返回0
            return 0;
        for(i=0;i<strlen(chars);i++)
        {
            t->ch[i] = *(chars+i);        
        }
        t->len = strlen(chars);            //数组的长度
        return 1;                          //返回1,操作成功
    }
    说明:这里的StrAssign函数的参数t使用的是指针,是因为结构体变量做做形参,用法和普通变量一样属于值传递方式,在子函数中要给t赋值,所以输入的是t的指针。与之对比的是(2)子函数中T是数组,传入的是数组的首地址(改变形参也就改变了实参)。

    字符串定义的五种方法

    第1种:

    char a[5]="hello";
    第2种:

    char a[]="hello";
    第3种:

    char* a="hello";
    第4种:

    char a[10];
    gets(a);
    第5种:

    char* a[5]={"hello",
    "nihao",
    "good",
    "ok",
    "bye"};

     

    展开全文
  • C语言字符串数组与指针数组 一.字符串数组 字符串数组实际就是char类型的二维数组 const char arr[][40] = { "char mjuik ", "char;; " , " hunh ba"}; //打印地址应该用%p十六进制的但是为了看得清楚就用十进制...

    C语言的字符串数组与指针数组

    一.字符串数组

    字符串数组实际就是char类型的二维数组

    const char arr[][40] = { "char                mjuik  ", "char;;  " , "           hunh ba"};
    //打印地址应该用%p十六进制的但是为了看得清楚就用十进制打印了
    cout << "arr和arr[0]指针没有移动时\n\n";
    printf("%d,%d\n", arr, arr[0]);
    

    打印结果大家都清楚 arr 和 arr[0] 指向的是同一个地址,但是指针同时加1就不一样了;

    cout << "arr和arr[0]指针同时+1时\n\n";
    printf("%d,%d\n", arr+1, arr[0]+1);
    

    打印结果
    在这里插入图片描述
    arr 是和arr[0]是同一个地址是不错,但是它们代表的不一样,arr是代表的是二维数组的首地址而arr[0]代表的是二维数组第一行的首地址,二个指针同时+1的话arr会指向二维数组第二行的首地址,arr[0]会指向二维数组第一行的第二个元素的地址.

    二.指针数组

    const char* arr[]= { "char                mjuik  ", "char;;  " , "           hunh ba"};
    	printf("arr指向的地址:%d\narr[0]指向的地址:%d\n", arr, arr[0]);
    	
    	printf("arr所指向的字符串:%s\n", arr);
    	printf("arr[0]所指向的字符串:%s\n", arr[0]);
    
    	cout << "char* 占" << sizeof(char*) << "字节" << endl;
    

    打印结果,这二个地址会没有任何联系,arr是二维数组的首地址了,它是存储char指针的数组,这个数组中有几个字符串就有arr指针数组中就有几个char的指针,这些char* 的指针指向了我们看到的这些字符串,
    在这里插入图片描述
    可以看到arr指向了乱码

    三.总结

    虽然指针数组和字符串数组(二维数组)都能实现相同的功能,但他们的原理是相差地别的,不是一个性质

    字符串数组(二维数组)都能实现相同的功能,但他们的原理是相差地别的,不是一个性质

    展开全文
  • C语言指针字符串数组位置颠倒,实现ABCDEFGHIJKLMNOPQRSTUVWXYZ转换成ZYXWVUTSRQPONNOPQRSTUVWXYZ
  • 原创 C语言:字符串数组与字符串指针数组 ...
    原创

    C语言:字符串数组与字符串指针数组

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
    本文链接: https://blog.csdn.net/Kobe51920/article/details/89607979

    1,首先,不论是局部,静态还是全局数组都必须在定义的时候初始化,否则就得通过其他方式,eg 循环操作,字符串处理函数strcpy()

    2,附以下代码: 主要完成将”I am from china ”倒置为”china from am I”,

    最开始编写时,将str定义为字符串数组,怎么都出不来结果。半天才发现应该用字符串指针数组

    3,那么问题来了,字符串数组和字符串指针数组有什么区别

    举个例子  char a[] = "hello";   //字符串数组,存放的是字符

                    char *b[] = {"hello", "world"};//字符串指针数组,存放的是指针即元素地址,指针指向其中的元素

    字符数组初始化  char a[10] ="hello";//字符串以'\0'结尾,这种方式系统会自动在数组未填值的地方添加'\0'

                               char b[] = {'h', 'e' , 'l', 'l', '\0'};//类似于初始化整型数组,必须要手动在后面添加'\0'

    所以当我 这样定义时char a[] = {"hello", "world"};,报错str中有多余的元素。

     

    详细说明:
         假定字符串数据中也以NUL结束字符串    

          char  arr1[10][100];

          char *arr2[10];

        内存: arr1是个字符串数组,分配内存 10 * 100 = 1000 个字节。
                  arr2是个字符串指针数组,分配内存 10 * 8 = 80 个字节。

      标识符: arr1是个该数组第一个指向 100 个char型数据内存的指针。
                    形象的理解,arr1是一篇文章(共10行)中的     第一行的首地址。
                    arr2是个该数组第一个指向  1  个char型数据(8字节)内存的指针。
                    形象的理解,arr2是一篇文章(共10行)中的第一行的     首字符地址。

    元素访问: 
            
            a.  arr1[4][0];
                 *arr2[4];
                它们都是用于表示访问各自数组中第4行的首字符。

            b.  arr1[4]
                 arr2[4]
                它们都是用于表达第4行字符串。
                arr1[4]是字符指针常量,arr2[4]是字符指针变量。

            c.  char (*parr1)[100];
                 char **parr2;
                 parr1 = arr1 + 4;
                 parr2 = arr2 + 4;
                定义了两个变量,分别接收了两个数组的第4行的数据。
                parr1是指向第4行拥有100个字符的一维数组。
                parr2定义一个指向第4列的一个指针。

            d.  char *str1, *str2, *str2, *str4;
                 str1 = arr1[4];
                 arr1[4]它就是arr1第4行这个有100个字符的一维数组名,是该数组首元素的指针常量。
                 str2 = *( arr1 + 4 )
                 arr1+4是指向arr1第4行字符的指针,进行间接访问后,得到第4行字符这个一维数组的数组名。
                 str3 = arr2[4];
                 arr2[4]是arr2的第4个元素,该元素是指向一个字符串的首元素指针。
                 str3 = *( arr2 + 4 )
                 arr2+4是指向arr2第4个元素的指针,进行间接访问后,得到第4个元素,该元素是一个指向一个字符串首元素的指针。

    字符串数组与字符串指针的共同点:
           arr1[4]、*( arr1 + 4 ) 字符指针常量。
           arr2[4]、*( arr2 + 4 ) 字符指针变量。
           它们都是字符指针,只不过一个可以修改指针值,一个不能修改指针值。
           指针变量需要初始化,指针常量在定义时已经完成了初始化。
           若字符串数组中的数据也以NUL结尾,那么这两种指针都可以用字符串标准库函数的实参(因为这些函数都不会改变指针值)。

     

    三种方法:

    1.在C语言中,是将字符串作为字符数组来处理的,字符串是逐个存放到数组元素中的,例如用一个一维的字符数组存放字符串"I am a boy.",如下代码:

    char c[12] = {'I','a','m','a','b','o','y','.'};
    这个字符串的实际长度是11,数组长度是12,实际工作中,人们关心的往往是字符串的有效长度而不是字符串的数组长度,例如要打印字符串,这是就要知道字符串的实际长度。平时常使用下面三种方式来测定字符串的实际长度:
    (1)在串值后面加一个不计入长度的结束标记字符,比如'\0'来表示串值的终结

    初始化一个字符串的方法如下,在最后添加'\0'

    char str[] = {'I','a','m','h','a','p','p','y','\0'};
    也可以直接使用字符串常量初始化字符数组(系统自动加上'\0'),这种方法符合人们的习惯。

    char str[] = "I am happy";
    或者
    char str[] = {"I am happy"};
    注意:不能使用下面的赋值方式:
    char str[20];
    str = "I am happy";
    但可以用字符指针指向这个字符串:
    char *str;
    str = "I love China";


    (2)将实际串长度值保存在数组0的下标下

    #define MAXSIZE 20                        //数组的长度
    typdef char String[MAXSIZE+1];
    初始化字符串的方法:

    String t;
    StrAssign(t,"I am happy");                
    int StrAssign(String T,char *chars)  
    {
        T[0] = strlen(chars);                //下标为0存放数组长度
        for(i=1;i<=strlen(chars);i++)        //下标位置从1开始存放数据
        {
            T[i] = *(chars+i-1);
        }
         return 1;
    }
    (3)使用结构体类型(自定义类型)

    #define MAXSIZE 20
    typedef struct{
        char ch[MAXSIZE];
        int len;                
    }String;
    其中:MAXSIZE表示串的最大长度,ch是存储字符串的一维数组,len是字符串的长度
    初始化函数示例:

     String t;
     StrAssign(&t,"I am happy");
    int StrAssign(String *t,char *chars)
    {
        int i;
        if(strlen(chars)>MAXSIZE+1)        //字符串的长度大于数组的长度,操作失败,返回0
            return 0;
        for(i=0;i<strlen(chars);i++)
        {
            t->ch[i] = *(chars+i);        
        }
        t->len = strlen(chars);            //数组的长度
        return 1;                          //返回1,操作成功
    }
    说明:这里的StrAssign函数的参数t使用的是指针,是因为结构体变量做做形参,用法和普通变量一样属于值传递方式,在子函数中要给t赋值,所以输入的是t的指针。与之对比的是(2)子函数中T是数组,传入的是数组的首地址(改变形参也就改变了实参)。

    字符串定义的五种方法

    第1种:

    char a[5]="hello";
    第2种:

    char a[]="hello";
    第3种:

    char* a="hello";
    第4种:

    char a[10];
    gets(a);
    第5种:

    char* a[5]={"hello",
    "nihao",
    "good",
    "ok",
    "bye"};

     

    文章最后发布于: 2019-04-27 21:46:19
    展开全文
  • const char* str[] = { "Hello","abc","applef","man","C程序设计","指针数组" }; const char* pdest = "指针数组"; static int str_search(const char*key, const char**pstr, int num) { int i; for (i = 0; ...

    字符串常识:
    1.以’\0’结尾,用" "括起来,字符是用’ ‘括起来
    2.字符串有字符数组和字符指针两种表现形式。字符数组不一定是字符串,有’\0’结束的字符数组才是字符串,但字符串一定是字符数组
    3.字符串常量是个地址常量,存放在文字常量区
    char s1=“abc”; char s2=“abc”; /* 这里s1和s2都是指向内存的同一个地址单元,即s1==s2,这个地址单元存放了"abc"的起始地址 */
    “abc”[0] == s1[0] == s2[0] == ‘a’
    “abc”[1] == s1[1] == s2[1] == ‘b’
    4.字符数组要看作用域和存储类型才能确定存放在内存的什么区域
    5.处理字符串常用string.h里面的字符串函数


    字符指针数组查找字符串:

    1.遍历数组,比较字符串大小判断是否相等

    int str_search1(const char*dststr, const char**srcstr, int num) //适用于全部字符串(字符数组和字符串常量)
    {
        int i;
        for (i = 0; i < num; i++)
        {
            if (strcmp(*srcstr++, dststr) == 0)       //从头遍历字符串数组,找到相等的字符串返回                    
            {
                return i;
            }
    		//srcstr++;
        }
        return -1;
    }
    

    2.上述使用了strcmp函数比较字符串大小,增加了时间和空间上的消耗,若对象是字符串常量,可以直接比较地址值

    int str_search2(const char*dststr, const char**srcstr, int num)//只适合字符串常量
    {
        int i;
        for (i = 0; i < num; i++)
        {
            if(*srcstr++==dststr)                   //从头遍历字符串数组,比较字符指针的值,利用字符串常量只有唯一的内存地址
            {
                return i;
            }
    		//srcstr++;
        }
        return -1;
    }
    

    3.上述的方法简单可观,但是当数组较大时,不能快速判断字符串在不在数组里面,每次寻找字符串都要遍历一次数组,不适应多次查找字符串的场景。此时可牺牲一下空间资源换取时间资源,使用静态数组存储字符串的存在状态。



    测试程序:

    #include <stdio.h>
    #include <string.h>
    
    const char* srcstr[] = { "Hello","我在那里!","我在哪里?","World","C语言","C++" };
    const char* dststr = "我在哪里?";   //字符串常量
    
    int str_search1(const char*dststr, const char**srcstr, int num) //适用于全部字符串(字符数组和字符串常量)
    {
        int i;
        for (i = 0; i < num; i++)
        {
            if (strcmp(*srcstr++, dststr) == 0)       //从头遍历字符串数组,找到相等的字符串返回                    
            {
                return i;
            }
    		//srcstr++;
        }
        return -1;
    }
    
    int str_search2(const char*dststr, const char**srcstr, int num)//只适合字符串常量
    {
        int i;
        for (i = 0; i < num; i++)
        {
            if(*srcstr++==dststr)                   //从头遍历字符串数组,比较字符指针的值,利用字符串常量只有唯一的内存地址
            {
                return i;
            }
    		//srcstr++;
        }
        return -1;
    }
    
    int str_search3(const char*dststr, const char**srcstr, int num)//只适合字符串常量
    {
        int i;
    	static int a[4096]={0};           //数组大小随字符指针数组大小而变
    	int start=(int)*srcstr;          //将地址值转换为int型进行运算,防止溢出可以使用unsigned long long并进行取余操作
    	int t=0;
        for (i = 0; i < num; i++)
        {
    		t=((start>(int)*srcstr)?(start-(int)*srcstr):((int)*srcstr-start));//将数组里面存在的字符串常量映射到数组上,并且保证数组下标t不小于0
    		a[t]=1;
    		srcstr++;			
        }
    	t=((start>(int)dststr)?(start-(int)dststr):((int)dststr-start));     
    	if(a[t]!=0)
    	{
    		return 0;          //查找成功,但未定位字符串位置
    	}
    	else
    	{
    		return -1;
    	}
    
    }
    
    int main()
    {
        int ret;
        ret = str_search1(dststr, srcstr, sizeof(srcstr) / sizeof(char*));
        if (ret != -1)
        {
            printf("查找成功\n");
    		printf("\"%s\"在%d号位置\n",dststr,ret);
        }
        else
        {
    		printf("查找失败,\"%s\"不在数组里\n",dststr);
    
        }
    
        getchar();
    	return 0;
    }
    

    结果:
    在这里插入图片描述
    在这里插入图片描述






    最后,当然方法还有很多,欢迎指点一下啦!大家共勉!

    展开全文
  • ——以字符’\0’结尾的char数组就是一个字符串,但如果char数组没有以’\0’结尾,那么就不是一个字符串,只是普通字符数组,所以字符串是一种特殊的char数组。 两者的区别: 字符串: 1、字符串赋初值用双引号引...
  • 预备知识:变量在内存的不同区域介绍C语言中,字符数组字符串指针都可以用来存储字符串:char *pstr = "china";char str[] = "china";但两者在内存中的存储区域是不一样的:字符指针的字符串存储在常量区;而字符...
  • 和数组形式定义的字符串相同,数组形式定义的字符串数组,存储了字符串字面量的副本,可以直接对这些字符串进行更改 d. 其中每个含有m个元素的数组必须不大不小的将数组填满,如果字符串长度小于m-1,其余位置就补...
  • 字符串数组排序(指针数组) Description 输入三个字符串,按由小到大的顺序输出,字符串长度小于1000 Input 3行字符串 Output 按照从小到大输出成3行 Sample Input cde afg abc Sample Output abc afg cde 具体...
  • C语言里的指针数组字符串等等这些东西在我编程入门的时候一直捋不清楚,而为什么捋不清楚,是因为我不知道程序运行时内存是怎么分区的,更不知道这些变量啊、常量啊究竟是放在内存里的什么地方。所以说,想清晰...
  • 字符 字符串 字符数组 字符串指针 指针数组

    千次阅读 多人点赞 2018-10-23 16:00:06
    字符指针:字符串指针变量本身是一个变量,用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘\0’作为串的结束。 char *ps=&quot;C Language&quot;; 顺序是:1....
  • 先说一下字符串字面量(字符串常量):双引号中的字符和编译器自动加入末尾的\0字符,都作为字符串储存在内存中。...字符串的赋值可以用指针数组,请看下面的例子 char str1[] = "I am a stude...
  • 指针数组比较适合用来指向若干个字符串,使字符串处理起来更加灵活 例:将若干字符串按字母顺序(从小到大)输出 思路: 定义指针数组name,用各字符串对它进行初始化(即把各字符串中的第1个字符的地址赋给指针...
  • C语言字符串与字符数组 1. 字符串与字符数组 1.1 C 语言字符串 什么是字符串? 通俗的讲字符串是由一串字符组成,例如 “Hello World\n”,即是一个字符串。 C 语言中没有真正意义上的字符串类型,字符串由字符...
  • 字符串指针数组详解

    万次阅读 多人点赞 2018-08-20 16:07:46
    #include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; int main(void) { char *str[] = {&...//*单独拿出来,指的是数组里的内容是*型的,str的类型是char *[]型 printf(&amp;amp;quot;%c\n&a
  • 1、字符数组的定义与初始化字符数组的初始化,最容易理解的方式就是逐个字符赋给数组中各元素。char str[10]={ 'I',' ','a','m',' ',‘h’,'a','p','p','y'};即把10个字符分别赋给str[0]到str[9]10个元素如果花括号...
  • C语言字符串数组排序问题

    万次阅读 多人点赞 2019-05-31 22:30:49
    在用C语言解决字符串排序问题时,遇到的些问题,记录一下; 字符串的排序与平常的数字排序方法,碰壁的地方在于做 ‘交换 ’ 这一步; 1. 这是用选择排序法对一个整型数组进行从大到小的排序; //选择排序法 #include...
  • 指针指针和字符串指针数组指针数组与普通数组的优缺点普通数组定义语法,优缺点指针数组、优缺点指针数组的定义通过指针数据修改变量字符串数组的定义字符串数组的遍历const 指针和字符串 字符常量有内存,可以取...
  • c语言中没有string类型的格式,字符串有两种表示方法 数组方式:char a[] = "wasd";...无论是数组申明还是指针申明的字符串,strlen()的大小都是字符数,字符串指针时sizeof(指针名)输出的是指针的大小,一般是四...
  • 1 指针字符串字符串可以看作是一种特殊的数组,所以使用指针处理字符串的时候可以完全按照处理数组的方式来进行#include%s占位符的特点就是只要告诉他字符串的首地址,就可以读取整个字符串但是字符串本身又有着自己...
  • 指针数组比较适合用来指向若干个字符串,使字符串处理起来更加灵活 例:将若干字符串按字母顺序(从小到大)输出 思路: 定义指针数组name,用各字符串对它进行初始化(即把各字符串中的第1个字符的地址赋给指针...
  • 前言 在日常敲代码的过程中我们会遇见这样一个问题 //例子1 ...例子2:这里我们换成一个指针,对指针int* a赋值,则不需要加取地址符号&,原因不难理解,上一个例子对a赋值需要其地址,所以我们
  • 第一种:使用二维数据来完成 void first_demo() { char str_list[3][10]={"zero","one","two"};...第二种:使用指针来完成 void second_demo() { char *p[]={"zero","one","two"}; int i; for(i=
  • 1. char str[] = "hello bit" 数组在栈上开辟空间,可以通过元素下标一个一个修改数组 2. char *p = "hello bit" 数组字符常量区开辟空间,不可被修改
  • #include <stdio.h> #define LENGTH 128 #define NUMBER 5 int main(void){ int i; char s[NUMBER][LENGTH]; for(i = 0;... puts("-----------打印字符串-----------"); for(i = 0; i <
  • 随机输入多组,5个省份的分数,找到最高分的位置 #include<stdio.h> int main() { int a[5],i,max,t; while(scanf("%d",&a[1])!=-1)//输入多组数据 { for(i=2;i<=5;i++) ... max=a...
  • C语言中关于字符数组和指针数组

    千次阅读 2016-10-21 20:04:27
    C语言中存储字符串有两种方法:字符数组字符串指针 这两者的存储位置不同,首先字符数组(局部变量)是保存在栈中的;指针指向字符串时,则包括了两部分,指针本身,存储在栈中(局部指针变量),字符串本身存储...
  • C语言中,将字符串作为字符数组来处理。C语言规定了一个“字符串结束标志”,以字符‘\0’代表。也就是说,在遇到第一个‘\0’字符时,表示字符串结束,由它前面的字符组成字符串。 一、字符数组字符串常量...
  • C语言指针数组实现字符串的排序 #include <stdio.h> #include <stdlib.h> #include <string.h> void sort(char *s[], int len) { int i,j; char *temp = (char *)malloc(sizeof(char) * 30)...
  • 二维字符数组比一维的字符指针数组功能更强大,因为字符串的值是存在于二维字符数组里面的,二维字符数组既可以保存字符串的值,也能够调用字符串的地址。 而一维的字符指针数组只能够保存字符串的地址,而不会去...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 102,634
精华内容 41,053
关键字:

c语言字符串指针数组

c语言 订阅