Guff_9hys

这个屌丝很懒，什么也没留下！

热门标签

C语言初阶重难点（含使用git上传github教程）_github c语言教程

作者：Guff_9hys | 2024-06-22 08:58:08

踩

github c语言教程

更偏向于个人笔记

1、git上传github

首先在github创建一个新仓库，复制仓库链接，再克隆到本地

//先定位到要克隆到的地址
cd /本地地址
git clone <git地址>
1
2
3

本地连接到github

cd /Users/xupeng/Documents/C_primary
git add .
git commit -m "注释"
git pull origin main
git push -u origin main
账号
密码:现在必须用密钥登录才行（2021年8月开始）
1
2
3
4
5
6
7

2、printf

//打印形式
%c --打印字符
%d --打印整数
%f --打印浮点数
%s --打印字符串
1
2
3
4
5

3、转义字符

\ddd  --表示8进制ASCII码
\xdd  --表示16进制ASCII码
1
2

4、操作符

//除号\两端必须要有一个小数才会是小数
float a=7.0/2 //3.5
//sizeof是操作符 计算所占内存大小
//strle是库函数，求字符串长度

//条件操作符  
//逗号表达式 (exp1,exp2,exp3,...)
//[]下标引用操作符  如arr[4] 操作数为arr和4
//()调用操作符 如Add(int a,int b) 操作数为Add、a和b
1
2
3
4
5
6
7
8
9

5、关键字

//extern 用来声明外部符号 （整个项目都可用全局变量g_val） 
//extern int g_val;
//extern int Add(int,int)
int g_val=10;//add.c文件
#include <stdio.h>//main.c文件

extern int g_val;
int main() {

    printf("%d\n",g_val);
    return 0;
}
//static修饰局部变量、全局变量和函数
//修饰局部变量：static是将局部变量从栈区放到静态区，这时的局部变量，出了作用域不销毁，下次进入作用域，使用的是上一次遗留的数据
#include <stdio.h>

extern int g_val;//声明外部全局变量

void test(){
    static int a=10;//将局部变量放到静态区，下次进入作用域，数据用的的上一次遗留的
    a++;
    printf("%d ",a);
}
int main() {
    int i=0;
    printf("%d\n",g_val);
    while (i<10){
        test();
        i++;
    }
    return 0;
}
//修饰局全局变量：全局变量是具有外部链接属性的，如果全局变量被static修饰，外部链接属性就变成了内部链接属性，其他源文件就没办法通过链接找到这个符号
static int g_val=10;

//修饰函数：函数是具有外部链接属性的，其他文件想要使用函数，只需要正确的声明就可以。如果函数被static修饰，这时候函数只能在自己的.c文件内部使用，.c文件外部不能使用

//整体：
#include <stdio.h>

extern int g_val;//声明外部全局变量
extern int Add(int ,int);//声明外部函数

void test(){
    static int a=10;//将局部变量放到静态区，下次进入作用域，数据用的的上一次遗留的
    a++;
    printf("%d ",a);
}

int main() {
    int i=0;
    printf("%d\n",g_val);
    while (i<10){
        test();
        i++;
    }
    int c= Add(2,3);
    printf("%d\n",c);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

6、指针

*pa;//*是解引用操作符
1

7、结构体

//结构体变量.结构体成员
//结构体指针->结构体成员
#include <stdio.h>

struct Stu{
    char name[20];
    int age;
    float score;
};

void Print(struct Stu* ps){
    printf("%s %d %f\n",ps->name,ps->age,ps->score);
}

int main(){
    struct Stu s1={"hh",22,99.9f};
    struct Stu s2={"ww",20,69.9f};
    scanf("%s %d %f",s2.name,&(s2.age),&(s2.score));
    printf("%s %d %f\n",s1.name,s1.age,s1.score);
    Print(&s2);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8、continue

continue会跳过本次循环后面的语句，直接去判断部分判断

#include <stdio.h>

int main() {
    int i=0;
    while(i<10){
        i++;
        if(5 == i)
            continue;//continue会跳过本次循环后面的语句，直接去判断部分判断
        printf("%d ",i);
    }
    return 0;
}
//for循环continue不会死循环
1
2
3
4
5
6
7
8
9
10
11
12
13

9、getchar和putchar

getchar()获取字符
putchar(int character)打印字符

#include <stdio.h>

int main() {
//    int ch = 0;
//    while((ch = getchar()) != EOF){
//        putchar(ch);
//    }
    char password[20] ={0};
    printf("请输入密码：>");
    scanf("%s",password);
    int temp = 0;
    while((temp = getchar()) != '\n'){ //把输入缓冲区的字符全部读出，包括\n
        ;
    }
    printf("请确认密码(Y/N):>");
    int ch = 0;
    ch = getchar();
    if(ch == 'Y')
        printf("确认成功");
    else
        printf("确认失败");
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

10、生成随机数

//设置随机数的生成器
srand((unsigned int)time(NULL));
//生成随机数
int r = rand()%100+1;//1~100的随机数
1
2
3
4

11、形参和实参

#include <stdio.h>

void Swap(int* pa,int* pb){
    int temp= *pa;
    *pa=*pb;
    *pb=temp;
}

//当函数调用的时候
//实参传给形参时，形参只是实参的一份临时拷贝
//所以对形参的修改不影响实参
//Swap(a,b);//传值调用

int main() {
    int a = 0;
    int b = 0;
    scanf("%d %d",&a,&b);
    printf("交换前的a=%d b=%d\n",a,b);
    Swap(&a,&b);  //传址调用
    printf("交换后的a=%d b=%d\n",a,b);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

12、数组

函数调用传的是数组的首元素地址，语法不支持将整个数组传递

要求数组长度可在调用前算好，再把长度作为实参传递到调用函数

#include <stdio.h>

int binary_search(int arr[],int x,int sz){
    int left = 0;
    int right = sz-1;
    while(left<=right){
        int mid = left+(right-left)/2;
        if(x > arr[mid]){
            left = mid+1;
        }
        else if(x < arr[mid]){
            right = mid-1;
        }
        else{
            return mid;
        }
    }
    return -1;

}
int main() {
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int x = 0;
    printf("请输入要查找的元素：");
    scanf("%d",&x);
    int sz = sizeof (arr)/sizeof (arr[0]);
    int ret = binary_search(arr,x,sz);
    if(-1 == ret)
        printf("没找到");
    else
        printf("找到了，数组下标为：%d",ret);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

二维数组表示

int arr[3][4] = {{1,2},{3,4},{5}};//初始化
// 1 2 0 0
// 3 4 0 0
// 5 0 0 0
1
2
3
4

数组名

#include <stdio.h>

//数组名是首元素地址（存在2个例外）
//2个例外：
//1、sizeof(数组名)是整个数组的大小
//2、&数组名是整个数组的地址
int main() {
    //数组
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    printf("%d\n",sizeof (arr));
    printf("%p\n",arr);
    printf("%p\n",arr+1);
    printf("%p\n",&arr[0]);
    printf("%p\n",&arr[0]+1);
    printf("%p\n",&arr);//整个数组的地址
    printf("%p\n",&arr+1);//整个数组的地址的下一个地址，即首元素地址+40
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

13、递归

#include <stdio.h>

 //递归调用
 void print(int n){
    if(n<10){
        printf("%d ",n);
    }
    else{
        print(n/10);
        printf("%d ",n%10);
    }
}

int main() {
    int input = 0;
    scanf("%d",&input);
    print(input);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

14、操作符详解

sizeof是计算数据占用内存空间的大小，单位是字节，不在乎内存放的是什么
strlen是计算字符串长度，只针对字符串，关注\0的位置，\0之前出现多少个字符，长度就是多少
```
char arr[]="abcdef";
//a b c d e f \0
sizeof(arr)/sizeof(arr[0]);//7
strlen(arr);//6
1
2
3
4
```

15、整型提升

表达式的整型运算要在CPU的相应运算器中进行，CPU内整型运算器（ALU）的操作数的字节长度一般为int字节长度，同时也是CPU的通用寄存器的长度

因此，即使是两个char类型相加，在CPU实际运行时也要先转换为CPU内整型操作数的标准长度

	char a = 5;
    //整型提升00000000000000000000000000000101
    char b = 126;
    //整型提升00000000000000000000000001111110
    char c = a + b;
    //00000000000000000000000000000101 -a
    //00000000000000000000000001111110 -b
    //00000000000000000000000010000011 -c
    //截断后10000011 -c
    printf("%d", c);//-125
    //再整型提升11111111111111111111111110000011 -c
    //c的原码10000000000000000000000001111101 -1 4 8 16 32 64
1
2
3
4
5
6
7
8
9
10
11
12

16、辗转相除法

int a = 0;
int b = 0;
int c = 0;
int d = 0;//存a*b
scanf("%d %d",&a,&b);
d = a*b;
//辗转相除法
while(a%b){
  c = a%b;
  a = b;
  b = c;
}
//此时b为最小公倍数
//最大公约数为d/b
1
2
3
4
5
6
7
8
9
10
11
12
13
14

17、多组输入

while (scanf("%d %d", &year, &month) != EOF) 
while ((ch = getchar()) != EOF)
1
2

18、指针数组

顾名思义，即存放指针的数组

int a = 0;
int b = 0;
int * arr[]={&a,&b};//整型指针数组
1
2
3

19、const用法

#include <stdio.h>

//const的用法
int main() {
    const int num = 10;
    //*num = 20;//不可修改
    int const *p = &num;//const 在*前面 p指针指向的内容（*p）不可修改 ,p指针可修改
    //*p=10;//不能修改
    p = 10;//指针可修改
    int *const pp = &num;//const 在*后面面 pp指针不可修改 ,pp指针指向的内容可以修改
    *pp = 99;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/746011