C语言入门（十八）之指针、字符串、函数

版权声明：如果觉得文章对你有用，转载不需要联系作者，但请注明出处 https://blog.csdn.net/jinxin70/article/details/83351402

如何利用指针操作数组

    int ages[3] = {1, 3 , 5};
    
    ages[0] = 998;
    printf("ages[0] = %i\n", ages[0]);
    
    int *p = ages; // int *p = &ages[0]; &ages[0] == ages
    printf("p = %p\n", p);
    printf("ages = %p\n", ages); // p == ages;
    
    // 以为p指针中存储的值和ages中存储的值相同, 所以以前用ages的地方都可以使用p来替代
    p[0] = 889;
    printf("ages[0] = %i\n", p[0]);
    
    for (int i = 0; i < 3; i++) {
        printf("p%i] = %i\n", i, p[i]);
    }

输出：

ages[0] = 998
p = 0x7ffeefbff60c
ages = 0x7ffeefbff60c
ages[0] = 889
p0] = 889
p1] = 3
p2] = 5

指针类型的两个用途: \
       第一个用途, 取值的时候, 会根据指针类型所占用的字节去取出对应字节的数据 \
       第二个用途, 用于做加法运算, 指针+1, 其实是加上指针类型所占用的长度 , 如果当前指针类型是int, 那么+1本质上是加上4个字节

int ages[3] = {1, 3 , 5};
    int *p;
    p = ages; // int *p = &ages[0];
    printf("ages[0] = %i\n", ages[0]);
    printf("*p = %i\n", *p);
    
    printf("p = %p\n", p);
//    p = &ages[1];
    // 指针+1, 并不是真实的+1, 而是+4
    // 指针类型的两个用途: \
       第一个用途, 取值的时候, 会根据指针类型所占用的字节去取出对应字节的数据 \
       第二个用途, 用于做加法运算, 指针+1, 其实是加上指针类型所占用的长度 , 如果当前指针类型是int, 那么+1本质上是加上4个字节
    p = p + 1;
    printf("p + 1 = %p\n", p);
    printf("*p = %i\n", *p);
    
//    p = &ages[2];
    p =  p + 1;
    printf("p + 1 = %p\n", p);
    printf("*p = %i\n", *p);

输出：

ages[0] = 1
*p = 1
p = 0x7ffeefbff60c
p + 1 = 0x7ffeefbff610
*p = 3
p + 1 = 0x7ffeefbff614
*p = 5

通过指针取数组元素：

    int ages[3] = {1, 3 , 5};
    int *p;
    p = ages;
    
    //printf("ages[0] = %i\n", *(p + 0));
    //printf("ages[1] = %i\n", *(p + 1)); // p = p + 1; *p;
    //printf("ages[2] = %i\n", *(p + 2));

    for (int i = 0; i < 3; i++) {
        // 指针+1, 是加上指针类型所占用的长度
        printf("ages[%i] = %i\n", i, *(p + i));
    }

输出：

ages[0] = 1
ages[1] = 3
ages[2] = 5

只要一个指针指向了数组, 那么访问数组就有3种方式:
     1. : ages[0];//通过数组变量和索引访问
     2. : p[0];//通过指针变量和索引访问
     3. : *(p + 0);//通过指针变量计算访问数组元素

指针和字符串

使用字符数组保存字符串

    char str[] = "lnj";
    printf("str = %s\n", str);
    str[0] = 'm';
    printf("str = %s\n", str);

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

通过指针保存一个字符串, 其实就是保存的字符串第0个元素的地址

    char *str2 = "lmj";
    printf("str2 = %s\n", str2);

通过数组保存字符串和通过指针保存字符串的区别

char *str2 = "lmj";
    printf("str2 = %s\n", str2);
////    str2[0] = 'm';
//    printf("str2 = %s\n", str2);
    
    
    // 通过数组保存字符串和通过指针保存字符串的区别
    // 如果通过数组来保存字符串, 那么字符串是一个变量 str  可以修改
    // 如果通过指针来保存字符串, 那么字符串是一个常量 str2 不能修该
    // 数组保存的字符串存储在内存的栈中, 而通过指针保存的字符串存储在常量区
    // 存储在栈中的变量有一个特点, 当作用域结束系统会自动释放该变量
    // 存储在常量区中的值有一个特点, 不会被释放, 而且多个相同的值对应的地址相同
    
    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);

输出

str2 = lmj
str3 = 0x7ffeefbff5e4
str2 = 0x100000f66
str4 = 0x100000f66

从输出可以看到str2和str4的地址相同，是同一个字符串常量。

小结：

保存字符串的两种方式:
     char str[] = "lnj";
     存储的位置: 栈
     特点: 相同的字符串会重复的分配存储空间
           字符串可以修改
     
     char *str = "lnj"
     存储的位置: 常量区
     特点: 相同的字符串不会重复的分配存储空间
            字符串不可以修改

注意: 用指针来保存字符串不可以被修改

指针没有初始化不能随便使用，所以数组变量和指针变量一样，未经初始化不能使用。

如何保存字符串数组

可以通过二维字符数组或者一维指针数组

char strs[4][20] =
    {
        "lnj",
        "lmj",
        "jjj",
        "lk"
    };

char *names[4] =
    {
        "lnj",
        "lmj",
        "jjj",
        "lk"
    };
    
    for (int i = 0; i < 4; i++) {
        printf("names[%i] = %s\n", i , names[i]);
    }

看如下两个函数

    char *name = demo();
    printf("name = %s\n", name);
    
    char *name2 = demo2();
    printf("name2 = %s\n", name2);


char *demo2()
{
    char name[]= "lnj";
    return name;
}

char *demo()
{
    char *name = "lnj";
    return name;
}

demo表示的字符串保存着常量池中，demo2表示的字符串保存在demo2栈中，所以name2输出后是一端脏数据。

练习：实现字符串长度的函数

char *name = "lnj";
//    size_t size = strlen(name);
    int size =myStrlen3(name);
    printf("size = %i\n", size);

int myStrlen3(char *str)
{
    int count = 0;
    // \0 ascii 0 // 0代表假 1真
    while (*str++)count++;
    
    return count;
}

指向函数的指针

函数也会占用一块存储空间
因为函数也会占用一块存储空间所以函数也由自己的地址
函数的地址保存在函数名中
函数名就是函数的地址 == 数组名就是数组的地址

指向函数的指针的定义格式
     void (*funtionP) ();

*    : 代表是一个指针
     funtionP    : 代表指针变量的名称, 区分
     (*funtionP) : 代表将来指向一个函数
     void : 代表将来指向的函数没有返回值
     ()   : 代表将来指向的函数没有参数

    void (*funtionP) ();
    funtionP = test; // 注意: 千万不能写成test()
    test(); // 0x100000f00();
    (*funtionP)(); // 0x100000f00()
    // test == funtionP
    funtionP();

#include <stdio.h>

void test()
{
    printf("哥被执行了\n");
}

int getAge()
{
    return 30;
}

void sum(int v1, int v2)
{
    int res = v1 +  v2;
    printf("res = %i\n", res);
}

int sum2(int v1 , int v2)
{
    int res = v1 + v2;
    return  res;
}
int main(int argc, const char * argv[]) {
    int (*ageP)();
    ageP = getAge;
    printf("age = %i\n", ageP());
    
//    void (*sumP)(int v1, int v2);
    void (*sumP)(int, int);
    sumP = sum;
    sumP(10, 20);

    
    int (*sumP2)(int , int);
    sumP2 = sum2;
    printf("sum = %i\n", sumP2(10, 20));

    return 0;
}

指向函数的指针的应用

可以用来写回调函数

#include <stdio.h>

int sum(int v1, int v2)
{
    return v1 + v2;
}

int minus(int v1, int v2)
{
    return v1 - v2;
}

// 让demo接受一个指向函数的指针
// 以后我们只需要给demo函数传递对应的指针, 那么函数内部就可以调用不同的函数
int demo(int v1, int v2)
{
    return minus(v1, v2);
}

int demo2(int v1, int v2)
{
    return sum(v1, v2);
}

int demo3(int v1, int v2, int (*p)(int, int))
{
    return p(v1, v2);
}

int main(int argc, const char * argv[]) {
    // 定义一个方法, 给你两个数, 用户要求你做加法你就做加法, 用户要求你做减法, 那你就做减法
//    printf("sum = %i\n", sum(10, 20));
//    printf("minus = %i\n", minus(20, 10));
    
//    printf("minus = %i\n", demo(20 , 10));
//    printf("sum = %i\n", demo2(20 , 10));
    
    printf("mins = %i\n", demo3(20, 10, minus));
    printf("sum = %i\n", demo3(20, 10, sum));
    
    return 0;
}

 练习2、将用户输入的字符串，首字母大写

#include <stdio.h>
char upper(char value);
void upperCase(char *p);
//void ts(char *temp);
void ts(char *temp, void (*funtionP)(char *));

int main(int argc, const char * argv[]) {
    // 需求: 要求用户输入一段英文, 将用户输入的英文单词所有的首字母大写
    // hello world --> Hello World
    
    
    // 1.接收用户输入的字符串
    // 2.遍历字符串, 判断当前字符是否是空格, 如果是空格就将下一个字符转换为大写
    
    // 1.先实现接受字符串
    // 2.再实现字母的大小写转换
    // 3.再实现替换字符串中的单词首字符
    
    /*
    printf("请输入一句英文, 单词之间用空格隔开\n");
//    char *str;
    char str[100];
//    scanf("%s", str);
    gets(str);
    printf("str = %s", str);
     */
    
    /*
    char c = 'a'; // + - 1
//    printf("c = %c\n", upper(c));
    upperCase(&c);
    // *p == c
    printf("c = %c\n", c);
     */
    
    // 1.接收用户输入的数据
    printf("请输入一句英文, 单词之间用空格隔开\n");
    char str[100];
    gets(str);
    // 注意: 数组名称不能做+1操作, 只有指针才可以
    printf("str = %s\n", str);
    /*
    char *temp = str;
    // 2.遍历字符串
    upperCase(temp);
    // temp == &str[0]
    while (*temp != '\0') { // h e l l o 空格 w
        // 2.1取出当前的字符, 判断是否等于 空格, 如果等于空格就需要将下一个字符转换为大写
        if ((*temp) == ' ') {
            // 2.2将下一个字符转换为大写
            upperCase(++temp); // temp == &str[6]; == w
        }else
        {
            temp++; // temp == &str[7];
        }
    }
     */
    ts(str, upperCase);
    
    printf("str = %s", str);
    
    return 0;
}

void ts(char *temp, void (*funtionP)(char *))
{
    // 1.不管三七二十一先将第一个字母转换为大写
    upperCase(temp);
    // temp == &str[0]
    while (*temp != '\0') { // h e l l o 空格 w
        // 2.1取出当前的字符, 判断是否等于 空格, 如果等于空格就需要将下一个字符转换为大写
        if ((*temp) == ' ') {
            // 2.2将下一个字符转换为大写
//            upperCase(++temp); // temp == &str[6]; == w
            funtionP(++temp);
        }else
        {
            temp++; // temp == &str[7];
        }
    }

}


void upperCase(char *p)
{
    // 1.判断是否是小写字母
    if (*p >= 'a' && *p <= 'z') {
        // 2.将小写字母转换为大写字母
        *p = *p - ('a'  - 'A'); // 32 小写的ascii大于大写
    }

}
char upper(char value)
{
    // 1.判断是否是小写字母
    if (value >= 'a' && value <= 'z') {
        // 2.将小写字母转换为大写字母
        value = value - ('a'  - 'A'); // 32 小写的ascii大于大写
    }
    return value;
}