精华内容
下载资源
问答
  • 字符串指针字符串指针与字符数组的区别与字符数组的区别 转载
  • C++处理字符串有两种方式,即:...接下来详细讲解一下字符串指针 首先,为什么字符串可以直接赋值给指针,即char* s = "HelloWorld"不会报错,不应该是把字符串的地址赋值给指针吗? 原因:这里的双引号做了3件...

    C++处理字符串有两种方式,即:指针方式和数组方式

    • 数组方式:char a[] = "HelloWorld";
    • 指针方式:const char* s = "HelloWorld";  const可以忽略

    接下来详细讲解一下字符串指针

    首先,为什么字符串可以直接赋值给指针,即char* s = "HelloWorld"不会报错,不应该是把字符串的地址赋值给指针吗?

    原因:这里的双引号做了3件事:  

    • 1.申请了空间(在常量区),存放了字符串 
    • 2. 在字符串尾加上了'/0'    
    • 3.返回地址

    为什么字符串指针的指针名输出字符串内容而不是地址?

    字符串指针的指针名代表字符串的首地址,但输出字符串指针名时输出的却是完整字符串,如下:

    	char* s = "HelloWorld";
    	cout<<s<<endl; //s是字符串的首地址,但却输出HelloWorld
    	cout<<*s<<endl;  //输出H
    	cout<<*(s+1)<<endl;  //输出e,s+1是第二个字符的地址
            cout <<static_cast<void *>(s) << endl; //此时输出的才是字符串地址

    原因是C++标准库中I/O类对<<操作符重载,在遇到字符型指针时会将其当作字符串名来处理,输出指针所指的字符串。既然这样,那么我们就别让它知道那是字符型指针,所以得用到强制类型转换,用static_cast把字符串指针转换成无类型指针

    字符串指针指向的地址可以修改,但所指向的字符串内容不能修改,因为字符串常量是不能改变的

    	char* s = "HelloWorld";
    	s="abcd"; //合法
    	cout<<*(s+1)<<endl;
    	*(s+1)='d'; //不合法,这里虽然没报错,但这一句实际下一句并未执行
    	cout<<s<<endl; //未执行

    字符串指针数组: 

    	char *p[6]={"ABCD","EFGH","IJKL","MNOP"};
    	int i;
    	for(i=0;i<4;i++) 
    		cout<<p[i]<<endl;  //输出每个字符串,实际上p[i]为第i个字符串的首地址
    	for(i=0;i<4;i++) 
    		cout<<*p[i];  //输出每个字符串第一个字符AEIM
    	cout<<endl;
    	for(i=0;i<4;i++) 
    		cout<<*(p[i]+1); //输出每个字符串第二个字符BFJN

     

     

     

     

     

     

     

    展开全文
  • 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"};

     

    展开全文
  • 字符 字符串 字符数组 字符串指针 指针数组

    千次阅读 多人点赞 2018-10-23 16:00:06
    字符指针:字符串指针变量本身是一个变量,用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘\0’作为串的结束。 char *ps=&quot;C Language&quot;; 顺序是:1....

    一、字符指针、字符数组

    1. 字符指针:字符串指针变量本身是一个变量,用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘\0’作为串的结束。

       char *ps="C Language";      顺序是:1.分配内存给字符指针;2.分配内存给字符串;3.将字符串首地址赋值给字符指针;
      
       可以写为:
      
       char *ps;  #ps字符串指针,是指针,是一个变量,
      
       ps="C Language"; #ps为字符串的首地址,利用ps++可遍历字符串,字符串存储在以ps为开始地址的地段连续的内存空间中,并以'\0'作为字符串的结束。
      

    这里有两点需要考虑清楚的地方:①*a只是指向一个字符。举例如下:

    1.#include <stdio.h>

    2.#include <stdlib.h>

    4.int main(void){

    5.char *a= “bcd” ;

    6.printf(“输出字符:%c /n”, *a); /输出字符,使用"%c"/

    printf(“输出字符:%c /n”, *(a+1) ); /输出字符,使用"%c"/

    7.printf(“输出字符串:%s /n”, a); /输出字符串,使用"%s";而且a之前不能有星号"" */

    8.system(“pause”); /为了能看到输出结果/

    9.}

    10./*运行结果如下:

    11.输出字符:b
    输出字符:c

    12.输出字符串:bcd*/

    ②若字符串常量出现在在表达式中,代表的值为该字符串常量的第一个字符的地址。所以”hello”仅仅代表的是其地址。原声明方式相当于以下声明方式:

    1.char *a;

    2.a=“hello”;/这里字符串"hello"仅仅代表其第一个字符的地址/

    1. 字符数组:字符数组是由于若干个数组元素组成的,它可用来存放整个字符串。(即用字符数组来存放字符串)。

                 在c语言中,将字符串作为字符数组来处理。(c++中不是)
      
                 字符数组初始化的方法:
      
                           1).  可以用字符串常量来初始化字符数组:char  str[]={"Iamhappy"};   可以省略花括号
      
                                                                                 char  str[]="Iamhappy";  #系统自动加入‘\0’
      
                           注意:上述这种字符数组的整体赋值只能在字符数组初始化时使用,不能用于字符数组的赋值,字符数组的赋值只能对其元素一一赋值。
      
                           下面的赋值方法是错误的:
      
                            char str[20];
      
                            str="Iamhappy";  
      
                            对字符数组的各元素逐个赋值。
      
                            char str[10]={'I','','a','m','',‘h’,'a','p','p','y'};
      

    在C语言中,可以用两种方法表示和存放字符串:

    (1)用字符数组存放一个字符串
    char str[]=“IloveChina”;
    (2)用字符指针指向一个字符串
    char *str=“IloveChina”;

    两种表示方式的字符串输出都用:printf(“%s\n”, str);

    %s表示输出一个字符串,给出字符指针变量名str(对于第一种表示方法,字符数组名即是字符数组的首地址,与第二种中的指针意义是一致的),则系统先输出它所指向的一个字符数据,然后自动使str自动加1,使之指向下一个字符…,如此,直到遇到字符串结束标识符"\0"。

    二、字符串指针

    string* str可以赋值string* str = {“hello”, “world”};//对比与char name = “wang” = {‘w’,‘a’,‘n’,‘g’}
    //?? (str) = “hello”, (str+1) = “world”
    //?? ((str)+1) = ‘e’,
    也就是说每个元素都是string类型的,跟char
    是不一样的,不过string
    可以用char**来代替//string = char
    , string* = char**

    三、(字符串)指针数组

    #include <stdio.h>
    void main()
    {
    char *str[] = {“Hello”, “C++”, “World”};//char (*str)[] = …
    int i;
    for(i=0; i<3; i++)
    printf("%s\n", str[i]);
    } #str[0]字符串“hello”的首地址,str[0]+1:字符串“hello”第二个字符‘e’的地址,str[2]=str+2:第三个字符串“world”的首地址

    #str[1]字符串“C++”的首地址

    #str[2]字符串“world”的首地址


    #include <stdio.h>
    #include <string.h>
    void main()
    {
    char *str[] = {“Hello”, “C++”, “World”};
    char **p;
    for(p=str; p<str+3; p++)
    puts(*p); #*p为字符串首地址,*p[0]为字符串的第一个字符地址
    }

    #include<stdio.h>
    #include<stdlib.h>
    main()
    {
    char str[3]={“Hello”,“C++”,“World”};
    printf("%s,%s,%c",str[0],str[0]+1,
    (*(str+2)+1));
    system(“pause”);
    }
    结果为:
    Hello,ello,o

    格式:char* na[N] = {“li”, “zh”, “li”, “zh”, “li”};

    char *a[]:表示a是数组,数组中的元素是指针,指向char类型,(数组里面所有的元素是连续的内存存放的)

    数组名是数组第一个字节的内存地址,并且数组名a也表示指针。所以a 并不表示a地址存储的内容, 而是a地址本身。
    a+1 表示a的第二个元素的内存地址, 所以是加8字节.( 因为a的元素是char 指针, 所需要的空间为8字节(64位内存地址). )
    (a+1) 则表示a这个数组的第二个元素的内容 (是个char 类型的指针. 本例表示为world字符串的地址).
    ((a+1)) 则表示a这个数组的第二个元素的内容(char指针)所指向的内容(w字符).
    char * a[10] 表示限定这个数组最多可存放10个元素(char指针), 也就是说这个数组占用10
    8 = 80字节.
    #w: a+1 => *(a+1) => *(a+1)[0]
    指针(地址) 指针内容(字符串) 字符

    四、
    char *argv:理解为字符串
    char **argv:理解为字符串指针
    char argv[]:字符串指针数组
    int main(int argc, char
    argv[])

    这是一个典型的数组名(或者说是指针数组)做函数参数的例子,而且还是没有指定大小的形参数组。

    有时为了再被调用函数中处理数组元素的需要,可以另设一个形参,传递需要处理的数组元素的个数。而且用数组名做函数实参时,不是吧数组元素的值传递给形参,而是把实参数组的首元素的地址传递给形参数组,这样两个数组久共同占有同一内存单元。  和变量作函数参数的作用不一样。 
    

    可以去看看关于数组作为函数参数和指针数组作main函数形参方面的例子。谭浩强的那本书讲的很细,对这个有详细的解释。

    1. 当char []作为函数的参数时, 表示 char *. 当作为函数的参数传入时, 实际上是拷贝了数组的第一个元素的地址 .
      所以 void test (char a[]) 等同于 void test ( char * a )
      char x[10] ; 然后调用 test(x) 则等同于把 x 的第一个元素的地址赋予给参数 a .

    2. char * a 和 char a[]
      相同点 : a都是指针, 指向char类型.
      不同点 : char a[] 把内容存在stack .
      char *a 则把指针存在stack,把内容存在constants.

    3. char * a[10] 和 char a[10][20]
      相同点 : a 都是2级指针, *a 表示一级指针, **a 表示内存中存储的内容.
      不同点 : char * a[10], 数组由char * 类型的指针组成;
      char a [10][20] 表示一位放10个元素, 二维放20个元素, 值存放地是一块连续的内存区域, 没有指针.

    4. 小窍门 : []和*的数量对应, 如 char a[][]的指针层数是2, 相当于char **a; char a[]也是如此, 两层指针. 迷糊的时候数数到底有几个几个[], 就知道什么情况下存储的是内容还是地址了? 如char a[][] 的情况里面: &a, a, *a 都是地址, **a 是内容.

    展开全文
  • 字符串与字符数组 字符串一定是一个char的数组,但char的数组未必是字符串。——以字符’\0’结尾的char数组就是一个字符串,但如果char数组没有以’\0’结尾,那么就不是一个字符串,只是普通字符数组,所以字符串...

    字符串与字符数组

    字符串一定是一个char的数组,但char的数组未必是字符串。——以字符’\0’结尾的char数组就是一个字符串,但如果char数组没有以’\0’结尾,那么就不是一个字符串,只是普通字符数组,所以字符串是一种特殊的char数组

    两者的区别:
    字符串:
    1、字符串赋初值用双引号引起来;
    2、以隐含的空字符\0结束,占用字节数+1,注意:1字节/字母,2字节/汉字;
    3、字符串可以使用%s格式化输出。
    普通字符数组:
    1、普通的字符数组赋初值用大括号引起来;
    2、不包含空字符,占用字节数不需+1;
    3、普通字符数组使用%s格式化输出,输出结果会乱码,因为没有’\0’结束符。
    例如:

    #include <stdio.h>
    #include <string.h>
    int main(void)
    {
        /*字符数组赋初值*/
        char cArr[] = {'I','L','O','V','E','C'};
        /*字符串赋初值*/
        char sArr[] = "ILOVEC";
        /*用sizeof()求长度*/
        printf("cArr的长度=%d\n", sizeof(cArr));
        printf("sArr的长度=%d\n", sizeof(sArr));
        /*用printf的%s打印内容*/
        printf("cArr的内容=%s\n", cArr);
        printf("sArr的内容=%s\n", sArr);
        return 0;
    }
    

    运行结果为:
    在这里插入图片描述
    如果定义:

     char cArr[] = {'I','L','O','V','E','C','\0'};
     char sArr[] = "ILOVEC";
    

    那么cArr与sArr就完全相同,都表示同一字符串。

    另外,%s格式化输出从当前地址到结束标志’\0’之前的所有字符,如:

    #include <stdio.h>
    #include <string.h>
    int main(){
        char str[] = "http://c.biancheng.net";
        printf("%s\n", str); //直接输出字符串
        printf("%s\n", str+1); //输出从第二个地址到最后的值
        printf("%s\n", str+2); //输出从第三个地址到最后的值
        return 0;
    }
    

    在这里插入图片描述
    通过对以上代码的分析,现在我们可以很简单地总结出字符数组和字符串二者之间的区别:
    对于字符数组,其长度是固定的,其中任何一个数组元素都可以为 null 字符。因此,字符数组不一定是字符串。
    对于字符串,它必须以 null 结尾,其后的字符不属于该字符串。字符串一定是字符数组,它是最后一个字符为 null 字符的字符数组。

    字符串数组与字符串指针

    字符串数组:

    //字符串数组
    #include <stdio.h>
    #include <string.h>
    int main(){
        char str[] = "http://c.biancheng.net";
        int len = strlen(str), i;
        //直接输出字符串
        printf("%s\n", str); //可以直接输出当前地址(字符串首地址)到结束标志'\0'之前的所有字符
        //每次输出一个字符
        for(i=0; i<len; i++){
            printf("%c", str[i]);
        }
        printf("\n");
        return 0;
    }
    

    字符串指针:

    //字符串指针
    #include <stdio.h>
    #include <string.h>
     
    int main(){
    char *str = "http://c.biancheng.net";
    int len = strlen(str), i;
     
    //直接输出字符串
    printf("%s\n", str); //可以直接输出当前地址(字符串首地址)到结束标志'\0'之前的所有字符
    //使用*(str+i)
    for(i=0; i<len; i++){
    printf("%c", *(str+i));
    }
    printf("\n");
    //使用str[i]
    for(i=0; i<len; i++){
    printf("%c", str[i]);
    }
    printf("\n");
     
    return 0;
    }
    

    运行结果都是:
    http://c.biancheng.net

    这一切看起来和字符数组是多么地相似,它们都可以使用%s输出整个字符串,都可以使用*或[ ]获取单个字符,这两种表示字符串的方式是不是就没有区别了呢?

    有!它们最根本的区别是在内存中的存储区域不一样,字符数组存储在全局数据区或栈区,第二种形式的字符串存储在常量区。全局数据区和栈区的字符串(也包括其他数据)有读取和写入的权限,而常量区的字符串(也包括其他数据)只有读取权限,没有写入权限。

    内存权限的不同导致的一个明显结果就是,字符数组在定义后可以读取和修改每个字符,而对于第二种形式的字符串,一旦被定义后就只能读取不能修改,任何对它的赋值都是错误的。

    我们将第二种形式的字符串称为字符串常量,意思很明显,常量只能读取不能写入。请看下面的演示:

    
    #include <stdio.h>
    int main(){
    char *str = "Hello World!";
    str = "I love C!"; //正确
    str[3] = 'P'; //错误
     
    return 0;
    }
    

    这段代码能够正常编译和链接,但在运行时会出现段错误(Segment Fault)或者写入位置错误。
    第4行代码是正确的,可以更改指针变量本身的指向;第5行代码是错误的,不能修改字符串中的字符。

    到底使用字符数组还是字符串常量
    在编程过程中如果只涉及到对字符串的读取,那么字符数组和字符串常量都能够满足要求;如果有写入(修改)操作,那么只能使用字符数组,不能使用字符串常量。

    最后我们来总结一下,C语言有两种表示字符串的方法,一种是字符数组,另一种是字符串常量(用指针表示),它们在内存中的存储位置不同,使得字符数组可以读取和修改,而字符串常量只能读取不能修改。

    展开全文
  • 字符串,字符指针,字符串指针,字符数组

    千次阅读 多人点赞 2019-01-06 13:04:02
    对于指针可能是大多数程序员最痛苦的事,尤其是指针和字符串和数组三者放在一起的时候,经历了几次错误后,我打算总结一下这几者的区别. ...字符串指针:char *p; 首先声明他是指针,p指向一个字...
  • C++中的字符串指针

    千次阅读 2019-12-10 14:31:38
    今天看C++时间与日期的库函数时出现如下程序: 序号 函数 & 描述 1 time_t time(time_t *time); 该函数返回系统的当前日历时间,自 1970 年 1 月 ... 该返回一个表示当地时间的字符串指针,字符串...
  • 字符串指针的定义、初始化与赋值

    千次阅读 2019-12-13 15:25:57
    指针的定义、初始化与赋值指针的定义、初始化与赋值char * 和 const char *用字符串常量给指针和数组赋值 指针的定义、初始化与赋值 char * 和 const char * const char *p1 ; char * const p1 ; const char * ...
  • C语言基础——字符串指针(指向字符串的指针)

    万次阅读 多人点赞 2018-07-25 09:57:15
    C语言中没有类似java,python等面向对象的编程语言中string那样的特定的字符串类型,通常是将字符串放在一个字符数组中。 遍历字符串代码: #include&lt;stdio.h&gt; #include&lt;string.h&gt; ...
  • 字符串指针数组详解

    万次阅读 多人点赞 2018-08-20 16:07:46
    //数组的首地址,即存放内容——字符串"abg"的地址,并非'a'的地址 return 0; } /* 指针数组相当于二位数组 str-->"abg"的地址,str+1 --->"cd"的地址 *str-->"abg"的首地址,即'a'的地址,*(str+1)--->"cd"的首...
  • 画红色重点——字符数组和字符指针的根本区别: ...因为 常量区没有写入权限,所以 当使用 strtok 函数处理 指针字符串时, char * str = "123s 123s 13s3"; strtok(str,s); 这样就必然会出错。 最后,关于 scan
  • C语言中没有特定的字符串类型,我们通常是将字符串放在一个字符数组中,这在《C语言字符数组和字符串》中已经进行了详细讲解,这里不妨再来演示一下: #include <stdio.h>int main(){ char str[] = ...
  • c# char*字符串指针

    千次阅读 2020-03-08 11:25:35
    Char *p =“hello”;这句话有两个意思: hello字符串是个常量,在...将hello字符串的首字符h的地址,赋值给指针p; bool isValid(char * s){ char* p; p = s; for(;*p!='\0';p++) { }//对字符串进行遍历 ...
  • 字符串指针数组的初始化

    千次阅读 2020-12-14 20:54:28
    没有开始赋值便出现想要输入字符串的行为 编译器会无情的嘲笑你…… 解决方法便是给每个指针分配个空间 在for循环中加入malloc函数 即可完成,缺点便是输入的字符有限,但这是不是算另一种优点呢…… ...
  • 字符串指针

    千次阅读 2015-06-22 23:57:41
    字符串指针  1)字符串指针  a、在C语言中,可以用两种方法访问一个字符串  ①字符数组  ②字符串指针指向字符串  char *变量名="字符串内容"; //"字符串内容"是常量  字符串指针变量的定义说明与指向字符变量...
  • C语言,字符串指针做函数参数

    千次阅读 2019-12-27 18:18:59
    str 是一个指针变量,也就是说 它存的是一个内存地址,这个内存地址指向类型是 char * 「也就是字符串」 但是把str 传给getMemory(char * p)的时候,它传递的是 str 的副本,不是它本身 既然传的是副本,在...
  • 字符串指针的一些注意事项

    千次阅读 2019-04-06 22:41:10
    最近使用strcpy的时候遇到一些以前没注意的坑,尤其是使用字符串指针的时候!这里做一个总结。 首先我们需要明白一件事情:当一个字符串指针指向的是一个字符串常量的时候,是不能通过该指针修改字符串的内容的!...
  • 浅谈C++字符数组与字符串指针

    千次阅读 多人点赞 2018-01-29 15:56:11
    如果将字符串字面值常量的首地址看作指针,那么这个指针是常指针常量(既是常指针,又是指针常量),即字符串指针本身只读而且其指向的内容(字符串的内容)只读。 C++处理字符串有两种方式,即:指针方式和数组...
  • 字符串指针与字符串数组

    千次阅读 2019-06-11 12:41:52
    C/C++中每一个字符串都以‘\0’结尾,以方便找出字符串的尾部。但由于这个特点,会存在额外的开销,不小心导致越界的情况。如下面的代码: char str[10]; strcpy(str,"0123456789"); "0123456789"看起来只有十个...
  • c中的字符串指针数组与字符

    千次阅读 2018-02-15 17:45:47
    c语言中要定义字符串的数组可以定义字符串指针数组,数组中定义了几个字符串指针字符串数组指针的赋值:字符串指针数组仅仅只是定义了几个指针,还需要为每个指针分配相应的内存空间char *p[4];for(int i=0;i&lt...
  • //字符串数组 #include <stdio.h> #include <string.h> int main(){ char str[] = "http://c.biancheng.net"; int len = strlen(str), i; //直接输出字符串 printf("%s\n", str); //每次输出一个...
  • 字符串指针 字符串的首地址; 字符串指针变量 例:char *strp=“hello”; 定义了一个指向字符串的指针变量,并将字符串的首地址赋值给strp指针变量,即:使指针变量strp指向字符串首地址; 输出: (1)printf(“%...
  • 字符串指针如何输入输出

    万次阅读 2018-12-18 22:13:50
    #include&lt;stdio.h&gt; #include&lt;string.h&gt; int main() { char *str="4564654"; printf("%s\n",str); int c,i; c=strlen(str); for(i=0;...字符串...
  • //字符串指针m中实际上存的是该字符串首字符的地址,所以用取内容运算符*对m进行操作即(*m)时,*m = b m = m+2 //m = def *m = d //m进行了+2,所以此时指针指的位置向后移动了两位,*m=d 将一个字符串指针赋给...
  • 关于C语言字符串指针的一点点总结

    千次阅读 2018-05-23 01:35:22
    一直在看指针的资料,今天实践了一次字符串指针的操作,做一个简单的总结。代码如下,:char * x = "abcd"; //声明一个字符类型的指针x 指向一个字符串需要特别注意的地方为:1、指针类型为char ,指针的...
  • 例如,定义一个函数,要求该函数能够返回一个指向字符串“I love C.”的指针并能在主程序中正确得到该字符串的内容。 对于初学者来说,当看到这个题目时,感觉并不难做到,可能很容易的写出下面形式的代码: ...
  • 字符数组和字符串指针的区别

    千次阅读 2018-06-10 08:46:18
    字符数组和字符串指针都可以用来存储字符串。除了形式上的区别,相差不大!给出一段代码#include&lt;iostream&gt; using namespace std; int main() { char a[10]="Hello!"; char *b="...
  • c语言:字符串与字符串指针变量

    千次阅读 2017-03-03 15:58:30
    1.字符数组由若干个元素组成,每个元素存放一个字符,而字符串指针变量中存放的是地址(字符串的首地址)。 例: #include"stdio.h" void main() { charstring1[] = "i am a student"; char*string2 = "i ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 695,396
精华内容 278,158
关键字:

字符串指针

友情链接: MYDIY_F407.zip