C 基础

.c 文件将使用 C 编译器

.cpp 文件将使用 C++ 编译器

---

基础

#include <stdio.h>

int main()
{
    // 代码
    return 0;
}

变量定义

数据类型 变量名;

数据类型 变量名1, 变量名2, 变量名3;

数据类型 变量名1 = 值, 变量名2 = 值;

数据类型 变量名 = NULL;  // NULL值

常量

常量无法被修改

// 变量
const 数据类型 变量名 = 值;

// 数组
const 数据类型 变量名[15] = {值1, 值2, 值3};

static

在全局声明 变量不会和其他文件共享, 在作用域声明 不会在结束作用域时而销毁 变量与程序的生命周期相等

static 变量类型 变量名称;

数组

数据类型 变量名[元素数量];    元素数量为数字

数据类型 变量名[15] = {值1, 值2, 值3};

// 访问
数组[下标]  

// 赋值
数组[下标] = 值

多维数组

数据类型 变量名[元素数量][元素数量];

数据类型 变量名[元素数量][元素数量][元素数量];

数据类型 变量名[15][10] = {{值1, 值2, 值3}, {值1, 值2, 值3}, {值1, 值2, 值3}};

强制类型转换

(数据类型)变量 

运算符

+    -    *    /    %

++运算对象    --运算对象    先赋值再输出 常用

运算对象++    运算对象--    先输出再赋值

>    >=    <    <=
==    !=

||    &&

!

表达式

变量名 = 条件? 值1: 值2

---

语法

sizeof(参数) 测量大小 可测量 数据类型 变量 常量

getchar() 清除未被吸收的输入 \n

putchar(变量) 输出一个值符

getch() 接收一个字符输入 #include <conio.h> 变量 = getch()

system("命令") 执行命令 #include <stdlib.h>

typedef 数据类型 名称 定义别名 不常用

Printf

printf("Hello Word 占位符", 值, 值);

%d 整型

%ld 整型 long

%lld 整型 long long

%f 浮点型

%c 字符型

%s 字符型 输出字符串

%u unsigned类型

%lu unsigned类型 long

%llu unsigned类型 long long

Scanf

scanf("%c", &变量);

scanf("%s", &变量);  // 接收字符串

If

if(条件)
{
    // 代码
}
else if(条件)
{
    // 代码
}
else
{
    // 代码
}

For

for(int i = 1; 条件; i++)
{
  // 代码
}

break 结束整个循环

continue 结束本次循环

While

while(条件)
{
    // 代码
}

break 结束整个循环

continue 结束本次循环

Switch

switch(变量)
{
    case 值:
        // 代码
        break;
    case 值:
        // 代码
        break;
    default:
        // 代码
}

Memcpy

数组 赋值给另一个 数组

#inclued <memory.h>

memcpy(目标数组, 被复制的数组, 复制的数据大小)

memcpy(目标数组, 被复制的数组, sizeof(被复制的数组))

---

函数

返回类型 函数名(数据类型 a, 数据类型 b)
{
    return 值;  // 返回值
}

void 代表没有返回值

函数声明, 让编译器知道有这个函数

返回类型 函数名(数据类型 a, 数据类型 b);

指针

&数据对象

获取数据对象的指针, 指针是数据对象在内存中的首地址

int n;

&n  // 指针 获取首地址

int* pn = &n;  // 存储指针

&数据对象: 获取指针

数据类型*: 存储指针 数据类型是指针对象类型

*指针

指针 转为 对象数据

*指针

通过指针修改值

*指针 = 值

指针指向的愿数据会被修改

struct

结构

// 多个
struct{
    成员变量;
    数据类型 变量1;
    数据类型 变量2;
}结构名[数量];

// 只有一个
struct{
    成员变量
}结构名{};

// 访问
结构名[元素].变量

// 赋值
结构名[元素].变量 = 值

// 初始化
结构名[元素].变量 = {值, 值};

结构可以潜逃

初始化赋值

// 初始化
struct{
    成员变量
}结构名[数量] = {{值, 值}, {值, 值}};

// 初始化
struct{
    成员变量
}结构名{} = {值, 值};

struct 结构名{
    成员变量
};

// 定义
struct 结构名 新结构名{};

// 访问
新结构名.变量;

//赋值
新结构名.变量 = 值;

// 初始化
新结构名.变量 = {值, 值};

// 初始化
struct 结构名 新结构名 = {值, 值};

struct 结构名{
    成员变量
};

// 定义
struct 结构名 新结构名[元素数量];

// 访问
新结构名[元素].变量;

//赋值
新结构名[元素].变量 = 值;

// 初始化
新结构名[元素] = {值, 值};

// 初始化
struct 结构名 新结构名[元素数量] = {{值, 值}, {值, 值}};

---

union

联合 成员变量共享值, 修改一个全改变

union{
    成员变量;
}联合名;

---

enum

枚举

enum 枚举名{
    名称 = 值;
    名称 = 值;
}

---

作用域

作用域内的变量只有在作用域内有效

{
  // 代码
}

---

引用

#include "print02.c"  // 引用的文件