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\n", str);
    str[0] = ‘m‘;
    printf("str = %s\n", str);

    // 因为数组名就是数组的地址, 数组名保存的就是数组的第0个元素的地址,所以我们可以使用指针来保存字符串

    // 通过指针保存一个字符串, 其实就是保存的字符串第0个元素的地址
    char *str2 = "lmj";
    printf("str2 = %s\n", str2);
    str2[0] = ‘m‘;  //字符串中的某一个字符 不能修改
    printf("str2 = %s\n", str2);

    /* 通过数组保存字符串和通过指针保存字符串的区别：
     1.如果通过数组来保存字符串, 那么字符串是一个变量 str  可以修改
     如果通过指针来保存字符串, 那么字符串是一个常量 str2 不能修该，
     2.数组保存的字符串存储在内存的栈中, 而通过指针保存的字符串存储在常量区
     存储在栈中的变量有一个特点, 当作用域结束系统会 自动释放该变量
     存储在常量区中的值有一个特点, 不会被释放, 而且 多个相同的值对应的地址相同*/

    char str3[] = "lnj";
    printf("str = %p\n", str);
    printf("str3 = %p\n", str3);//地址不一样

    char *str4 = "lmj";
    printf("str2 = %p\n", str2);
    printf("str4 = %p\n", str4);//地址一样

    // 利用指针保存字符串的应用场景
    for (int i = 0; i < 100; i++) {
        // 意味着会开辟100块存储空间来保存xmg这个字符串，并且会释放100次，性能问题，
        char str5[] = "xmg";
        char *str6 = "xmg";
        printf("str5 = %s\n", 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\n", *p); //报错

    char str[10];
    scanf("%s", str);//可以存进去
    printf("str = %s\n", str);

    // 1.指针没有初始化, 野指针,没有指向任何地址，没法存，
    char *str;
    scanf("%s", str);    //报错
    printf("str = %s\n", 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\n", 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\n", 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\n", nums[0]);

    char *name = demo();//name指向常量区"lnj"所在的区域
    printf("name = %s\n", name);

    char *name2 = demo2();
    printf("name2 = %s\n", 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\n", size);
    return 0;
}

int myStrlen3(char *str)   //str[i],*str++,数组名和指针名的使用是一样的，xx[]和xx*是数组类型的两种形式，
{
    int count = 0;
    // \0 ascii 0 // 0代表假 1真
    while (*str++) count++;

    return count;
}

int myStrlen2(char *str)
{
    int count = 0;
    //    *str == str[0]
    while (*str++ != ‘\0‘) {
        count++; // 1
//        str = str + 1; // str == str[1]
//        str++; // ++可以在变量名前, 也可以在变量名后
    }
    return count;
}

int myStrlen(char *str)
{
    int count = 0;
    while (str[count] != ‘\0‘) {
        count++;
    }
    return count;
}