• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

[C语言]进阶|指针与字符串[C语言]指针与字符串

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

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

回顾:[C语言]指针与字符串

 

指针的使用:

/**
 * main.c by weiChen in 2015-5-4
 */
#include <stdio.h>

//定义函数体,使在main方法中能调用
void swap(int *pa, int *pb);
void minmax(int c[], int len, int *min, int *max);
int divide(int d, int e, int *result);

int main(void)
{
    /*
     指针应用场景:
     1. 交换两个变量的值

     2. 函数返回多个值,某些值就只能通过指针返回;
        传入的参数实际上是需要保存带回的结果的变量(注:函数中指针的值将作为参数传入函数);

     3. 函数返回运算的状态,结果通过指针返回;
        常用的套路是让函数返回特殊的不属于有效范围内的值来表示出错;
            -1或0(在文件操作会看到大量的例子)
        但是当任何数值都是有效的可能结果时,就得分开返回了;
               后续的语言(c++,java)采用了异常机制来解决这个问题
     4. 指针常见错误:定义了指针变量,还没有指向任何变量,就开始使用指针
     */
    int a = 5;
    int b = 6;
    swap(&a, &b);
    printf("a=%d,b=%d\n", a, b);

    int c[] = {1,2,3,4,5,9,30,13,45,59};
    int min,max;
    minmax(c, sizeof(c)/sizeof(c[0]), &min, &max);
    printf("min=%d, max=%d\n", min, max);

    int d = 19;
    int e = 3;
    int f;
    if(divide(d, e, &f)) {
        printf("%d/%d=%d\n", d, e, f);
    }
    
    int i = 8;
    int *p;
    int k;
    k = 12;
    *p = 12;//未初始化变量,直接给指针赋值;一旦指针所指的位置不可写,程序将报错
    printf("&i=%p\n", &i);//Segmentation fault

    return 0;
}

//交换两个值
void swap(int *pa, int *pb)
{
    int t = *pa;
    *pa = *pb;
    *pb = t;
}

//求最小最大值
//虽然*min,*max是作为参数传进去的,但作用是得到结果,带入
void minmax(int a[], int len, int *min, int *max)
{
    int i;
    *min = *max = a[0];
    for(i=0; i<len; i++) {
        if(a[i] < *min) {
            *min = a[i];
        }
        if(a[i] > *max) {
            *max = a[i];
        }
    }
}

//@return 如果除法成功,返回1;否则返回0
int divide(int d, int e, int *result)
{
    int ret = 1;
    if(e == 0) {
        ret = 0;
    } else {
        *result = d/e;
    }
    return ret;
}

 

/**
 * main.c by weiChen in 2015-5-4
 */
#include <stdio.sh>

int main(void) 
{
    /*
     指针与const
     指针可以是const: 0xaffefado
     值可以是const: 45
     */

    /*
     指针是const: 表示一旦得到了某个变量的地址,不能再指向其他变量
         int *const q = &i;    //q的值是const,值是i的指针
        *q = 26; //OK
        q++;    //ERROR
     */
     
    /*
     所指是const:表示不能通过这个指针去修改那个变量(并不能使得那个变量成为const)
         const int *p = &i;
        *p = 26;    //ERROR, (*p是const)
        i = 26;        //OK
        p = &j;        //OK
     */

    /*
     int i;

     const int *p1 = &i; \
                          |    指针不能被修改
     int const *p2 = &i; /

     int *const p3 = &i;

     //判断哪个被const了的标志是const在*的前面还是后面
     */

    /*
     转换:总是可以把一个非const的值转换成const的
     void f(const int *x);    //意思:传入一个const指针参数,但函数内部不会更改这个指针所指的值
     int a = 15;            //可以传入一个非const的指针的值
     f(&a);    //OK

     const int b = a;        //也可以传入一个非const的指针的值
     f(&b);    //OK
     b = a + 1; //ERROR
     
     //当要传递的参数的类型比地址大的时候,这是常用的手段:既能用比较少的字节数传递值给参数,又能避免函数对外面的变量的修改
     */

    /*
     const数组:
     const int a[] = {1,2,3,4,5,6,};
     数组变量已经是const的指针了,这里的const表明数组的每个单元都是const int (即a[0]等均为const)
     所以必须通过初始化进行赋值
     */

    /*
     保护数组值:
     因为把数组传入函数时传递的是地址,所以那个函数内部可以修改数组的值
     为了保护数组不被函数破坏,可以设置参数为const
         int sum(const int a[], int length);    //不希望函数对参数作修改
     */

    return 0;    
}

 

指针的计算: 

/**
 * main.c 
 */
#include <stdio.h>

int main(void)
{
    char ac[] = {0,1,2,3,4,5,6,};    //char数组
    char *p = ac;     //*p指向数组的第一个单元
    printf("p = %p\n", p);            //p = 0x7fff51f1dc15
    printf("p + 1 = %p\n", p + 1);    //p + 1 = 0x7fff51f1dc16

    int ai[] = {0,1,2,3,4,5,6,};   //int数组
    int *q = ai;    //*p指向数组的第一个单元
    printf("q = %p\n", q);             //q = 0x7fff50160bf0
    printf("q + 1 = %p\n", q + 1);     //q + 1 = 0x7fff50160bf4

    printf("sizeof(char)=%ld\n", sizeof(char));    //1
    printf("sizeof(int)=%ld\n", sizeof(int));    //4

    /*
     指针的计算:
         在指针上加1,是移到下一个单元,给实际的指针值加上sizeof类型的值
        两个指针相减,值是两个指针的差除以sizeof类型的值
     */
    
    //    *p -> ac[0]
    //    *(p+1) -> ac[1]
    //     *(p+n) -> ac[n]
    // 加1如果不加上sizeof(类型)的值,得到的其实并不是我们想要的

    // 给指针加1表示要让指针指向下一个变量:
    //    int a[10];
    //    int *p = a;
    //    *(p+1) -> a[1];
    // 如果指针不是指向一片连续分配的空间,如数组,则这种运算没有意义

    /*
     指针计算:
         给指针加减一个整数(+, +=, -, -=)
        递增递减(++/--)
        两个指针相减:值是有几个sizeof类型的值存在
     */
    while(*p!=-1) {
        printf("%d\n", *p++);
    }
    /*

     *p++
        取出p所指的那个数据,顺便把p移到下一个位置去
        *的优先级虽然高,但是没有++高
        常用于数组类的连续空间操作
        在某些cpu指令上,这可以直接被翻译成一条汇编指令
     */

    /*
     指针比较:
         <, <=, ==, >, >=, != 都可以对指针做
         比较他们在内存中的地址
         数组中的单元的地址肯定是线性递增的
     */
    
    /*
     0地址:
        当然你的内存中有0地址,但是0地址通常是个不能随便碰的地址
        所以你的指针不应该具有0值
        因此可以用0地址来表示特殊的事情
            返回的指针是无效的
            指针没有被真正初始化(先初始化为0)
        NULL是一个预定义的符号,表示0地址,有些编译器不识别小些的null
            有的编译器不愿意你用0来表示0地址
     */

    /*
     指针的类型:
         无论指向什么类型,所有的指针的大小都是一样的,因为都是地址
        但是指向不同类型的指针是不能直接互相赋值的
        这是为了避免用错指针
     */

    /*
     指针的类型转换:
         void* 表示不知道指向什么东西的指针
            计算时与char* 相同(但不相通)
        指针也可以转换类型
            int *p = &i; void *q = (void*)p;//通过p看i是一个int,通过q看i是一个void(强制类型转换后赋给q)
        这并没有改变p所指的变量的类型,而是让后人用不同的眼光通过p看它所指的变量
            不再当你是int,而认为是void
     */

    /*
     用指针来做什么:
         需要传入较大的数据时用作参数
        传入数组后对数组做操作
        函数返回不止一个结果
            需要用函数来修改不止一个变量
        动态申请的内存
     */
    return 0;
}

 

 动态内存分配:

//  main.c
//  Created by weichen on 15/6/10.
//  Copyright (c) 2015年 weichen. All rights reserved.
#include <stdio.h>
#include <stdlib.h>

int main(int argc, const char * argv[]) {
    /*
     动态内存分配
     
     输入数据:输入数据时,先告诉你个数,然后再输入,要记录每个数据
     C99可以用变量做数组定义的大小,C99之前呢?int *a = (int*)malloc(n*sizeof(int));
    
     #include <stdlib.h>
     void* malloc(size_t size);
     1. 向malloc申请的空间的大小是以字节为单位的
     2. 返回的结果是void*,需要类型转换为自己需要的类型
     3. (int*)malloc(n*sizeof(int));
     */
    
    int number;
    int* a;
    int i;
    
    printf("输入数量:");
    scanf("%d", &number);
    // int a[number];   // C99写法
    a = (int*)malloc(number*sizeof(int));   //malloc返回的void*,所以需要类型转换一下,现在a就可以当做数组使用
    
    for (i=0; i<number; i++) {
        scanf("%d", &a[i]);
    }
    for (i=number; i>=0; i--) {
        printf("%d", a[i]);
    }
    
    free(a);    // 归还内存
    
    return 0;
}

 

/**
* main.c
*/
#include <stdio.h> #include <stdlib.h> int main(int argc, const char * argv[]) { // malloc:如果空间申请失败则返回0或者NULL void *p = 0; //free可以释放0或NULL,避免free的地址没有被分配时出错,习惯初始化指针为0 int cnt = 0; // 如果p的地址不是0(得到了地址),循环继续 while( (p = malloc(100*1024*1024)) ) { cnt++; } printf("分配了%d00MB的空间\n", cnt); free(p); /* p = malloc(100*1024*1024); p++; // pointer being freed was not allocated p = &i; // pointer being freed was not allocated free(p); */ /* 把申请得到的空间还给“系统” 申请过的空间,最终都应该要还 只能还申请来的空间的首地址 常见问题: 申请了没有free,长时间运行内存逐渐下降:忘了或找不到合适的free的时机 free过了再free 地址变过了,直接取free */ return 0; }

 

字符串操作:

/**
 *  main.c
 */

#include <stdio.h>

int main(int argc, const char * argv[]) {
    /*
     单字符输入输出: putchar,getchar
     
     int putchar(int c);
     向标准输出写一个字符
     返回写了几个字符,EOF (-1)表示写失败(end of file)
     
     int getchar(void);
     从标准输入读入一个字符
     返回类型是int是为了返回EOF (-1):Windows->Ctrl-Z
                                   Unix->Ctrl-D
     */
    
    int ch;
    
    while( (ch = getchar()) != EOF ) {
        putchar(ch);
    }
    
    return 0;
    
    /*
     字符串数组:
     char **a;
        a是一个指针,指向另一个指针,那个指针指向一个字符(串)
     char a[][1];
     
     */
}

 

字符串函数实现:

//  main.c
//  Created by weichen on 15/6/23.
//  Copyright (c) 2015年 weichen. All rights reserved.

#include <stdio.h>
#include <string.h>
//自定义求长度的函数 int mylen(const char *s) { int index = 0; //知道长度用for循环, 不知道用while while (s[index] != '\0') { index++; } return index; } int main(int argc, const char * argv[]) {
   /**
   * size_t strlen(const char *s);
* 返回s的字符串长度(不包括结尾的0)
   */
char line[] = "hello";
   printf(
"strlen=%d\n", strlen(line)); //strlen=5 printf("strlen=%d\n", mylen(line)); printf("sizeof=%d", sizeof(line)); //sizeof=6 return 0; }

 

//  main.c
//  Created by weichen on 15/6/23.
//  Copyright (c) 2015年 weichen. All rights reserved.
#include <stdio.h> #include <string.h> int mycmp(const char *s1, const char *s2) { //当做数组处理:用一个整数当做下标,遍历字符串 /* int index = 0; while (1) { if(s1[index] != s2[index]) { break; } else if(s1[index] == '\0') { break; } index++; } return s1[index] - s2[index]; */ //直接用指针:指针加加,判断指针所指的值 while (1) { if(*s1 != *s2) { break; } else if(*s1 == '\0') { break; } s1++; s2++; } return *s1 - *s2; //好看的写法 /* while (*s1 == *s2 && *s1 != '\0') { s1++; s2++; } return *s1 - *s2; */ } int main(int argc, const char * argv[]) { /** * strcmp * int strcmp(const char *s1, const char *s2); * 比较两个字符串,返回: * 0 :s1==s2 * 1 :s1 >s2 * -1:s1 <s2 */ char s1[] = "abc"; char s2[] = "abc "; printf("%d\n", strcmp(s1, s2)); //0 printf("%d\n", mycmp(s1, s2)); //判断两个字符串是否相等的写法 if(strcmp(s1, s2) == 0) { printf("s1 = s2"); } else { printf("s1 != s2"); } return 0; }

 

//  main.c
//  Created by weichen on 15/6/23.
//  Copyright (c) 2015年 weichen. All rights reserved.

#include <stdio.h>
#include <string.h> char* mycmp(char *dst, const char *src) { /* 数组方式 int index = 0; while(src[index] != '\0') { dst[index] = src[index]; index++; } //src所有的字符串复制完后,dst还差一个结尾的0,需要加上去 dst[index] = '\0'; return dst; */ //指针方式 char* ret = dst; while (*src != '\0') { *dst = *src; src++; dst++; } *dst = '\0'; return ret; } int main(int argc, const char * argv[]) { /** * strcpy * char * strcpy(char *restrict dst, const char *restrict src); * 把src的字符串拷贝到dst,restrict表明src和dst不重叠(C99) * 返回dst,为了能链起代码来 */ /* 复制一个字符串的套路 char *dst = (char*)malloc(strlen(src) + 1); //不知道要复制的字符串占多大空间,所以需要动态分配内存,strlen只能求出字符串的大小,不包含结尾的0 strcpy(dst, src); */
  
   char s1[] = "abc";
   char *str = (char*)malloc(strlen(s1) + 1);
strcpy(str, s1);
   printf("%s", str); return 0; }

 

//  main.c
//  Created by weichen on 15/6/26.
//  Copyright (c) 2015年 weichen. All rights reserved.
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, const char * argv[]) {
    /*
     在字符串中找单个字符
     char* strchr(const char *s, int c);
     char* strrchr(const char *s, int c);
     返回NULL表示没有找到
     */
    
    char s[] = "hello";
    char *p = strchr(s, 'l');
    printf("%s\n", p);  //llo
    
    //找第二个l
    char *q = strchr(p + 1, 'l');
    printf("%s\n", q);  //lo
    
    //从右边开始找
    char *a = strrchr(s, 'l');
    printf("%s\n", a);  //lo
    
    //复制找到的字符串
    char *r = (char*)malloc(strlen(p) + 1); //1.动态分配内存空间
    char *t = strcpy(r, p);                 //2.复制字符串
    printf("%s\n", t);  //llo
    free(r);                                //3.释放动态分配的内存空间
    
    //找l之前字符的技巧
    char c = *p;
    *p = '\0';          //将*p所指的位置替换为\0; s就变成了he\0lo
    char *u = (char*)malloc(strlen(s) + 1);
    char *v = strcpy(u, s);
    printf("%s\n", v);  //he
    printf("%s\n", s);  //he
    free(u);
    
    //最后将*p恢复为l
    *p = c;
    printf("%s\n", s);  //hello
    
    
    /*
     字符串中找字符串
     char* strstr(const char *s1, const char *s2);
     字符串中找字符串,并忽略大小写
     char* strcasestr(const char *s1, const char *s2);
     */
    char x[] = "E";
    char y[] = "e";
    char *z1 = strstr(s, x);    //如果第二个参数x改为字符'E',就会报错,因为函数接受的参数是一个指针;
    char *z2 = strstr(s, y);
    char *z3 = strcasestr(s, x);
    printf("%s\n", z1); //null
    printf("%s\n", z2); //ello
    printf("%s\n", z3); //ello
    
    /*
     连接两个字符串
     extern char* strcat(char *dest, char *src);
     */
    char ab[10] = "good";
    char *cd = "bye";
    strcat(ab, cd);
    printf("%s\n", ab); //goodbye
    
    return 0;
}

//注:PHP中strchr是strstr的别名,因为里面没有指针一说,所以第一第二个参数均为字符串。

 

Refer:C语言指针的重要性

Link:http://www.cnblogs.com/farwish/p/4477897.html


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
abstractvirtual在C++和C#中的比较发布时间:2022-07-13
下一篇:
C#ListView点击列头进行排序发布时间:2022-07-13
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap