C语言个人笔记

c语言基础知识梳理，供大家参考，查阅。

指针数组

1. 定义：

本质是数组，里面存放的是指针

1. 格式：

存储类型 数据类型 *数组名[元素个数]

int *arr[3] = {};

1. 应用实例：

3.1. 用于存放普通变量的地址

int a = 10, b = 20, c = 30;

int *arr[3] = {&a, &b, &c};

访问b的地址：

arr[1] *(arr+1)

访问 b 的值

*(arr[1]) *(*(arr+1))

3.2. 用于存放二维数组的每一行第一个元素的地址(列地址)

int a[2][3] = {1, 2, 3, 4, 5, 6};

int *arr[2] = {a[0], a[1]};

访问 a[1][2] 的地址：

arr[1]+2 *(arr+1)+2

arr：第一个元素的地址

arr+1：第二个元素的地址

*(arr+1)：第二个元素：a[1]：第二行第一列的地址

*(arr+1)+2：第二行第三列的地址  &a[1][2]

3.3. 用于存放字符串

char str[32] = "hello";   // 存放的是整个hello字符串

char *str = "hello";   // 存放的是hello字符串的首地址

    char str[32] = "hello";

    char *strs = "hello";

    printf("%s\n", str);

    printf("%s\n", strs);

    printf("%p %p\n", strs, &str[0]);

    printf("%c %c\n", *(strs+1), str[1]);

使用指针数组存放字符串

char *str[3] = {"hello", "world", "xiaomisu7"};

打印 "xiaomisu7" 字符串

    char *str[3] = {"hello", "world", "xiaomisu7"};

    printf("%s\n", str[2]);  // xiaomisu7

    printf("%s\n", *(str+2));  // xiaomisu7

    printf("%s\n", *(str+2)+4);  // misu7

打印 'm' 这个字符

    printf("%c\n", *(*(str+2)+4));  // m

    printf("%c\n", *(str[2]+4));  // m

练习：用指针将整型组s[8]={1,2,3,4,5,6,7,8}中的值逆序存放。

练习：用变量a给出下面的定义（3C科技、宇视科技，神思电子，中安云科，北京凝思软件）

a) 一个整型数:· int a;

b) 一个指向整型数的指针: int *a;

c) 一个指向指针的的指针，它指向的指针是指向一个整型数: int **a;

d) 一个有10个整型数的数组: int a[10];

e) 一个有 10个指针的数组，该指针是指向一个整型数的 int *a[10];

f) 一个指向有 10个整型数数组的指针: int (*a)[10];

g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数:

h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数

函数

1. 定义

一个完成特定功能的代码模块

1. 三要素

功能、参数、返回值

1. 格式

存储类型 数据类型 函数名(参数列表)

{

函数体;

}

1. 没有参数：参数列表可以省略，也可以用void
2. 没有返回值：数据类型为 void , 函数内部没有return语句。
3. 有返回值：要根据返回值的数据类型定义函数的数据类型
4. 定义子函数时直接定义在主函数上面，如果定义在主函数下面需要提前声明函数

1. 函数声明

数据类型 函数名(参数列表);  // 形参

1. 函数调用

1. 没有返回值：直接调用：函数名(实参);
2. 有返回值：如果需要接收返回值，就要定义一个与返回值类型相同的变量去接收

如果不需要接收返回值，就直接调用函数

#include <stdio.h>

void fun()
{
     
     
    printf("hello\n");
}

void add1(int a, int b)
{
     
     
    printf("sum = %d\n", a + b);
}

int add2(int a, int b)
{
     
     
    return a + b;
}

int sub(int a, int b);

int main(int argc, char const *argv[])
{
     
     
    fun();
    add1(1, 2);
    int sum = add2(3, 5);
    printf("%d\n", sum);
    int su7 = sub(7, 3);
    printf("%d\n", su7);

    return 0;
}

int sub(int a, int b)
{
     
     
    return a - b;
}

练习1：编写一个函数，函数的2个参数，第一个是一个字符，第二个是一个char *，返回字符串中该字符的个数。

#include <stdio.h>

int count(char c, char *s)
{
     
     
    int n = 0;
    while (*s != '\0')
    {
     
     
        if(c == *s)
        {
     
     
            n++;
        }
        s++;
    }
    return n;
}

int main(int argc, char const *argv[])
{
     
     
    printf("请输入一个需要查找的字符:");
    char c = getchar();
    char str[32];
    printf("请输入一个字符串:");
    scanf("%s", str);
    int num = count(c, str);
    printf("查找到该字符个数为:%d个\n", num);

    return 0;
}

练习2：编程实现strlen函数的功能，strlen计算字符串实际长度，不包含’\0’

1. 函数传参
   1. 值传递

单向传递，将实参传递给形参使用，改变形参实参不会受到影响

#include <stdio.h>

int fun(int num, int sum)
{
     
     
    num++;
    sum++;
    return num + sum;
}

int main(int argc, char const *argv[])
{
     
     
    int a = 3, b = 4;
    int ret = fun(a, b);
    printf("%d %d %d\n", a, b, ret);  // 3 4 9
    return 0;
}

1. 1. 地址传递

双向传递，在函数中修改形参，实参也会随之变化

#include <stdio.h>

int fun(int *num, int *sum)
{
     
     
    (*num)++;
    (*sum)++;
    return *num + *sum;
}

int main(int argc, char const *argv[])
{
     
     
    int a = 3, b = 4;
    int ret = fun(&a, &b);
    printf("%d %d %d\n", a, b, ret);  // 4 5 9
    return 0;
}

1. 1. 数组传递

和地址传递一样，参数中存在数组的定义，它也会认为是一个指针

#include <stdio.h>

char *fun2(char a[32])
{
     
     
    a = "hello";
    
    char *str = "hello";
    // 如果是数组的话是 32， 如果是指针的话是4
    printf("%d\n", sizeof(a));  // 4
    return a;
}

int main(int argc, char const *argv[])
{
     
     
    char *ch = fun2("abc");
    printf("%s\n", ch);
    
    char *str = "hello";
    return 0;
}

补充：

char *p = "hello";
//