zoukankan      html  css  js  c++  java
  • c19---指针和字符串

    //
    //  main.c
    //  指针和字符串
    //
    //  Created by xiaomage on 15/6/14.
    //  Copyright (c) 2015年 xiaomage. All rights reserved.
    //
    
    #include <stdio.h>
    
    int main(int argc, const char * argv[]) {
        // 保存字符串
        char str[] = "lnj";//字符串 这个字符数组名 也是char*类型,
        printf("str = %s
    ", str);
        str[0] = 'm';
        printf("str = %s
    ", str);
        
        // 因为数组名就是数组的地址, 数组名保存的就是数组的第0个元素的地址,所以我们可以使用指针来保存字符串
        
        // 通过指针保存一个字符串, 其实就是保存的字符串第0个元素的地址
        char *str2 = "lmj";
        printf("str2 = %s
    ", str2);
        str2[0] = 'm';  //字符串中的某一个字符 不能修改
        printf("str2 = %s
    ", str2);
        
        /* 通过数组保存字符串和通过指针保存字符串的区别:
         1.如果通过数组来保存字符串, 那么字符串是一个变量 str  可以修改
         如果通过指针来保存字符串, 那么字符串是一个常量 str2 不能修该,
         2.数组保存的字符串存储在内存的栈中, 而通过指针保存的字符串存储在常量区
         存储在栈中的变量有一个特点, 当作用域结束系统会 自动释放该变量
         存储在常量区中的值有一个特点, 不会被释放, 而且 多个相同的值对应的地址相同*/
        
        char str3[] = "lnj";
        printf("str = %p
    ", str);
        printf("str3 = %p
    ", str3);//地址不一样
        
        char *str4 = "lmj";
        printf("str2 = %p
    ", str2);
        printf("str4 = %p
    ", str4);//地址一样
        
        
        
        
        // 利用指针保存字符串的应用场景
        for (int i = 0; i < 100; i++) {
            // 意味着会开辟100块存储空间来保存xmg这个字符串,并且会释放100次,性能问题,
            char str5[] = "xmg";
            char *str6 = "xmg";
            printf("str5 = %s
    ", str6);
        }
        
        /*
         保存字符串的两种方式:
         char str[] = "lnj";
         存储的位置: 栈
         特点: 相同的字符串会重复的分配存储空间
               字符串中的字符可以修改
         
         char *str = "lnj"
         存储的位置: 常量区
         特点: 相同的字符串不会重复的分配存储空间
                字符串不可以修改
         */
        
        return 0;
    }
    //
    //  main.c
    //  指针和字符串注意点
    //
    
    #include <stdio.h>
    
    int main(int argc, const char * argv[]) {
        
        // 指针没有被初始化不能随便使用, 野指针
        int *p;
        printf("*p = %i
    ", *p); //报错
        
        char str[10];
        scanf("%s", str);//可以存进去
        printf("str = %s
    ", str);
        
        
        // 1.指针没有初始化, 野指针,没有指向任何地址,没法存,
        char *str;
        scanf("%s", str);    //报错
        printf("str = %s
    ", str);
        
        // 注意: 用指针来保存字符串不可以被修改
        // 指针没有初始化不能随便使用
        return 0;
    }
    //
    //  main.c
    //  指针数组,字符串数组
    //
    
    #include <stdio.h>
    
    int main(int argc, const char * argv[]) {
        
        
        char str1[] = "lnj";
        char str2[] = "lmj";
        char str3[] = "jjj";
        char str4[] = "lk";
        
        char strs[4][20] =
        {    //字符串数组是二维数组
            "lnj",
            "lmj",
            "jjj",
            "lk"
        };
        
        
        char *str1 = "lnj";  //char []  ===  char *  ===  " ... "
        char *str2 = "lmj";
        char *str3 = "jjj";
        char *str4 = "lk";
        
        
        // 定义数组的格式: 元素类型 数组名称[元素的个数]
        int  a = 10;
        int  b = 20;
        int nums[2] = {10 , 20};
        
        char* names[4] =     //每一个元素是char*也就是char[],也可以是字符串,
        {
            "lnj",
            "lmj",
            "jjj",
            "lk"
        };
        
        for (int i = 0; i < 4; i++) {
            printf("names[%i] = %s
    ", i , names[i]);
        }
        
        
        
        return 0;
    }
    //
    //  main.c
    //  指针类型的特点
    //
    //  数组名即是xx[]也是xx*类型,字符串名即是char[]类型也是char*类型
    //    xx[]和xx*是数组类型的两种形式,
    //
    
    #include <stdio.h>
    void change();
    void change2();
    void change3(int values[]);
    void change4(int *p);
    char *demo();
    char *demo2();
    
    int main(int argc, const char * argv[]) {
        /*
         只要是数据类型就具备3个特点
         1.可以用来定义变量
         2.可以用来作为形参的类型
         3.作为返回值
         */
        
        int num = 10;
        change(num);
        printf("num = %i
    ", num);
        
        char *name = "lnj";//指针指向字符串是一个常量,字符串的字符不能更改,
        change2(name);
        
        int nums[] = {1, 3, 5}; // int[] === int*, nums是int[]类型也是int*类型,
        change3(nums); // 数组名就是数组的地址,998
        change4(nums); // 数组名就是数组第0个元素的地址,998
        printf("nums[0] = %i
    ", nums[0]);
        
        
        char *name = demo();//name指向常量区"lnj"所在的区域
        printf("name = %s
    ", name);
        
        char *name2 = demo2();
        printf("name2 = %s
    ", name2);
        
        return 0;
    }
    
    char *demo2() //name和"lnj"都在函数所在的栈区域,"lnj"占4个字节,函数执行结束后销毁,
    {
        char name[]= "lnj";
        return name;
    }
    
    char *demo() //demo函数会在栈中开辟存储区域,name在函数所在的区域内,"lnj"不在函数所在的内存区域而是在常量区,
    {
        char *name = "lnj";//字符串名即是char*类型也是char[]类型,
        return name;
    }
    
    void change4(int *p)
    // int *p = nums; == int *p = &nums; == int *p = &nums[0]
    // int *p; p = nums;  p == nums;
    {
        p[0] = 998;
    }
    // 不专业
    void change3(int values[])
    {
        values[0] = 998;
    }
    
    
    void change2(char *p)
    {
        *p = "lmj";//不能更改
    }
    
    
    void change(int value)
    {
        value = 55;
    }
    //
    //  main.c
    //  指针练习
    //
    //  Created by xiaomage on 15/6/14.
    //  Copyright (c) 2015年 xiaomage. All rights reserved.
    //
    
    #include <stdio.h>
    #include <string.h>
    int myStrlen(char *str);
    int myStrlen2(char *str);
    int myStrlen3(char *str);
    
    int main(int argc, const char * argv[]) {
        // 要求自己实现strlen函数
        char *name = "lnj";
        size_t size = strlen(name);
        int size =myStrlen3(name);
        printf("size = %i
    ", size);
        return 0;
    }
    
    
    int myStrlen3(char *str)   //str[i],*str++,数组名和指针名的使用是一样的,xx[]和xx*是数组类型的两种形式,
    {
        int count = 0;
        //  ascii 0 // 0代表假 1真
        while (*str++) count++;
        
        return count;
    }
    
    int myStrlen2(char *str)
    {
        int count = 0;
        //    *str == str[0]
        while (*str++ != '') {
            count++; // 1
    //        str = str + 1; // str == str[1]
    //        str++; // ++可以在变量名前, 也可以在变量名后
        }
        return count;
    }
    
    int myStrlen(char *str)
    {
        int count = 0;
        while (str[count] != '') {
            count++;
        }
        return count;
    }
  • 相关阅读:
    HDU2027 统计元音 一点点哈希思想
    湖南工业大学第一届ACM竞赛 数字游戏 字符串处理
    湖南工业大学第一届ACM竞赛 我素故我在 DFS
    HDU3293sort
    HDU2082 找单词 母函数
    HDU1018 Big Number 斯特林公式
    湖南工业大学第一届ACM竞赛 分糖果 位操作
    UVA 357 Let Me Count The Ways
    UVA 147 Dollars
    UVA 348 Optimal Array Multiplication Sequence
  • 原文地址:https://www.cnblogs.com/yaowen/p/7390220.html
Copyright © 2011-2022 走看看