C/C++编程笔记：C语言入门知识点（一），请收藏C语言最全笔记

C 语言是一种通用的高级语言，最初是由丹尼斯·里奇在贝尔实验室为开发 UNIX 操作系统而设计的。C 语言最开始是于 1972 年在 DEC PDP-11 计算机上被首次实现。

原文链接：https://juejin.im/post/5df8c917f265da339772a5d1#heading-10

在 1978 年，布莱恩·柯林汉（Brian Kernighan）和丹尼斯·里奇（Dennis Ritchie）制作了 C 的第一个公开可用的描述，现在被称为 K&R 标准。

UNIX 操作系统，C编译器，和几乎所有的 UNIX 应用程序都是用 C 语言编写的。由于各种原因，C 语言现在已经成为一种广泛使用的专业语言。

易于学习。

结构化语言。

它产生高效率的程序。

它可以处理底层的活动。

它可以在多种计算机平台上编译。

这是只说明在 MAC 上怎么使用 C 语言来进行开发，环境的话需要用到 GCC 进行编译，你可以下载并安装 Xcode 工具，一旦安装上 Xcode，您就能使用 GNU 编译器。开发工具你可以使用 Xcode 或者 CLion 都可以，看个人喜好。我这里用的是 CLion 工具，你可以发现 CLion 页面跟使用风格包括快捷键都跟 AndroidStudio 一样。上手极其容易。

我们先来看一下最简单的一个 C 程序，先来打印一个 “HelloWorld”。代码如下:

#include <stdio.h>

/**

* C 语言入口程序

* @return

*/

int main() {//主函数，程序从这里开始执行

printf('C 语言入门第一行代码 Hello World! ');

return 0;

}

可以看到 C 语言的入口函数跟 Java 的类似吧，都是以main来定义的入口，接下来我们讲解一下上面这段程序的意思：

（1）程序的第一行#include <stdio.h>是预处理器指令，告诉 C 编译器在实际编译之前要包含 stdio.h 文件。

（2）下一行 /.../ 将会被编译器忽略，这里放置程序的注释内容。它们被称为程序的注释。

（3）下一行int main()是主函数，程序从这里开始执行。

（4）下一行printf(...)是 C 中另一个可用的函数，会在屏幕上显示消息 'C 语言入门第一行代码 Hello World!'。

（5）下一行return 0;终止 main() 函数，并返回值 0。

当然你可以通过命令来执行,如下所示：

1. 使用 gcc xxx.c

2. ./a.out

直接使用上面 2 个步骤就可以进行执行 C 代码了。

上一小节我们知道了一个简单的小应用由哪些部分组成，这将有助于我们理解 C 语言的其它基本的构建块。

c 程序由各种令牌组成，令牌可以是关键字、标识符、常量、字串符值、或者是一个符号。

下面我们来看一下 C 中的关键字，这些关键字不能作为常量名，变量名或者其它标识符名称（跟 Java 类似）。

在 C 语言中，数据类型指的是用于声明不同类型的变量或函数的一个广泛的系统。变量的类型决定了变量存储占用的空间，以及如何解释存储的位模式。

C 中的类型可分为以下几种：

整数类型

下表列出了关于标准整数类型的存储大小和值范围的细节

注意: 各种类型的存储大小与系统位数有关，但目前通用的以 64 为系统为主。

浮点类型

他们的字节，精度，取值范围都可以通过代码打印实现，如下：

void main() {

/**

* 整数类型

*/

printf(' 整数类型 ');

//char 1 字节

printf('char 存储大小: %lu ', sizeof(char));

printf('unsinged char 存储大小: %lu ', sizeof(unsigned char));

//short 2 字节

printf('short 存储大小: %lu ', sizeof(short));

printf('unsinged short 存储大小: %lu ', sizeof(unsigned short));

//int 4 字节

printf('int 存储大小: %lu ', sizeof(int));

printf('unsinged int 存储大小: %lu ', sizeof(unsigned int));

//long 4/8 字节

printf('long 存储大小: %lu ', sizeof(long));

printf('unsinged long 存储大小: %lu ', sizeof(unsigned long));

/**

* 浮点类型

*/

printf(' 浮点类型 ');

//float 4 字节 ，精度 6 位小数

printf('float 存储最大字节数：%lu ', sizeof(float));

printf('float 最小值：%e ', FLT_MIN);

printf('float 最大值：%e ', FLT_MAX);

printf('float 精度值：%d ', FLT_DIG);

//double 8 字节

printf('double 存储最大字节数：%d ', sizeof(double));

printf('double 最小值：%e ', DBL_MIN);

printf('double 最大值：%e ', DBL_MAX);

printf('double 精度值：%d ', DBL_DIG);

//long double 16 字节

printf('long double 存储最大字节数：%lu byte ', sizeof(long double));

printf('long double 最小值：%lg ', LDBL_MIN);

printf('long double 最大值：%lg ', LDBL_MAX);

printf('long double 精度值：%d ', LDBL_DIG);

}

可以通过 sizeof 关键字来获取数据类型占用内存的大小。上面代码可以看到了打印中出现了很多不识的 scanf() 格式控制符，我总结了一个表，可以参考下；

变量其实只不过是程序可操作的存储区的名称。C 中每个变量都有特定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。

变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的，因为 C 对大小写敏感的。

C 中的变量定义

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：

type list;

在这里，type必须是一个有效的 C 数据类型，可以是 char、w_char、int、float、double 或任何用户自定义的对象，list可以由一个或多个标识符名称组成，多个标识符之间用逗号分隔。下面列出几个有效的声明：

int a,b,c;

char c1,c2,c3;

float f,f1,f2;

double d1,d2,d3;

这里其实跟 Java 声明变量差不多，就不再单独解释了。

c 中变量声明

变量声明向编译器保证变量以指定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。

变量的声明有两种情况：

1、一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。

2、另一种是不需要建立存储空间的，通过使用 extern 关键字声明变量名而不定义它。 例如：extern int a 其中变量 a 可以在别的文件中定义的。

3、除非有 extern 关键字，否则都是变量的定义。

extern int i;//声明，不是定义

int a;//声明，也是定义

例子

#include <stdio.h>

//函数外定义变量

//如果需要在一个源文件中引用另外一个源文件中定义的变量，我们只需在引用的文件中将变量加上 extern 关键字的声明即可

int x;

int y;

int sum() {

//函数内声明变量 X , Y 为外部变量

x = 10;

y = 15;

return x + y;

}

//入口函数

void main() {

//打印变量相加

int result;

result = sum();

printf('x + y = %d',result);

}

输出：x + y =25

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。

常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。

常量就像是常规的变量，只不过常量的值在定义后不能进行修改。

在 Java 中声明一个常量往往是在数据类型中定义 final 关键字就行了，但是 c 中没有 final 关键字，我们来看看怎么定义，如下所示:

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。

212 /* 合法的 */

215u /* 合法的 */

0xFeeL /* 合法的 */

078 /* 非法的：8 不是八进制的数字 */

032UU /* 非法的：不能重复后缀 */

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。带符号的指数是用 e 或 E 引入的。

3.14159 /* 合法的 */

314159E-5L /* 合法的 */

510E /* 非法的：不完整的指数 */

210f /* 非法的：没有小数或指数 */

.e55 /* 非法的：缺少整数或分数 */

定义常量

在 C 中，有两种简单的定义常量的方式：

使用 #define 预处理器。

使用 const 关键字。

下面是使用 #define 预处理器定义常量的形式：

#define identifier value

例子：

#define name 10L

#define age 27U

void main() {

int person;

person = name + age;

printf('values :%d',person);

}

const 关键字

您可以使用 const 前缀声明指定类型的常量，如下所示：

const type variable = value;

例子：

void main() {

const int LEGTH = 10;

const int WIDTH = 5;

const char NEWLINE = ' ';

int area;

area = LEGTH * WIDTH;

printf('value of area: %d', area);

}

存储类定义 C 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C 程序中可用的存储类：

auto

register

static

extern

auto 存储类

auto 存储类是所有局部变量默认的存储类。

int month;

auto int month;

上面定义了两个带有相同存储类，auto 只能用在函数内，即 auto 只能修饰局部变量。

register 存储类

register存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。

register int miles;

寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义register并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

static 存储类

static存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

全局声明的一个 static 变量或方法可以被任何函数或方法调用，只要这些方法出现在跟 static 变量或方法同一个文件中。

//函数声明

void func1(void);

static int count = 10; //全局变量 - static 默认的

void main() {

while (count--) {

func1();

}

}

void func1(void) {

// 'thingy' 是 'func1' 的局部变量 - 只初始化一次

// * 每次调用函数 'func1' 'thingy' 值不会被重置。

static int thingy = 5;

thingy++;

printf('thingy 为 %d, count 为 %d ', thingy, count);

}

输出：

thingy 为 6, count 为 9

thingy 为 7, count 为 8

thingy 为 8, count 为 7

thingy 为 9, count 为 6

thingy 为 10, count 为 5

thingy 为 11, count 为 4

thingy 为 12, count 为 3

thingy 为 13, count 为 2

thingy 为 14, count 为 1

thingy 为 15, count 为 0

实例中 count 作为全局变量可以在函数内使用，thingy 在局部使用 static 修饰后，不会在每次调用时重置。

extern 存储类

extern存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用extern时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用extern来得到已定义的变量或函数的引用。可以这么理解，extern是用来在另一个文件中声明一个全局变量或函数。

extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：

第一个文件 ndk_day1.c

#include <stdio.h> //stdio.h 是一个头文件（标准输入输出头文件）,#include 是一个预处理命令，用来引入头文件。

#include 'support.h' //引入自己的头文件

int main() {

int sum = add(2, 5);

printf('extern 使用 :%d', sum);

}

声明 support.h 头文件

int add(int num1,int num2){

return num1 * num2;

}

输出：

extern 使用 :10

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C 语言内置了丰富的运算符，并提供了以下类型的运算符：

算术运算符

关系运算符

逻辑运算符

位运算符

赋值运算符

杂项运算符

算术运算符

下表显示了 C 语言支持的所有算术运算符。假设变量A的值为 10，变量B的值为 20，则：

例子：

void main(){

int a = 21;

int b = 10;

int c;

c = a + b;

printf('a + b = %d ', c);

c = a - b;

printf('a - b = %d ', c);

c = a * b;

printf('a * b = %d ', c);

c = a / b;

printf('a / b = %d ', c);

c = a % b;

printf('a % b = %d ', c);

c = ++a;

printf('++a = %d , %d ', c, a);

c = b++;

printf('b++ = %d , %d ', c, b);

c = b--;

printf('b-- = %d ', c);

}

输出：

a + b = 31

a - b = 11

a * b = 210

a / b = 2

a b = 1

++a = 22 , 22

b++ = 10 , 11

b-- = 11

关系运算符

下表显示了 C 语言支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

逻辑运算符

下表显示了 C 语言支持的所有关系逻辑运算符。假设变量 A 的值为 1，变量 B 的值为 0，则：

例子：void main(){

int a1 = 5;

int b1 = 5;

int c1;

//如果两个操作数都非零，则条件为真。

if (a1 && b1) {

printf('a1 && b1 %d ', true);

} else {

printf('a1 && b1 %d ', false);

}

//如果两个操作数中有任意一个非零，则条件为真。

if (a1 || b1) {

printf('a1 || b1 %d ', true);

} else {

printf('a1 || b1 %d ', false);

}

//改变 a1 b1 的值

a1 = 0;

b1 = 10;

//如果两个操作数都非零，则条件为真。

if (a1 && b1) {

printf('a1 && b1 %d ', true);

} else {

printf('a1 && b1 %d ', false);

}

if (!(a1 && b1)) {

printf('!(a1 && b1) %d ', true);

} else {

printf('a1 || b1 %d ', false);

}

}

输出：

a1 && b1 1

a1 || b1 1

a1 && b1 0

!(a1 && b1) 1

位运算符

例子：

void main(){

//位运算符 & | ^ ~

int wA = 60; //0011 1100

int wB = 13; //0000 1101

int wC = 10;

//都为真，才是真 0000 1100

printf('wA & wB=？%d ', wA & wB);

//其中一个为真，就为真 0011 1101

printf('wA | wB=？%d ', wA | wB);

//一个为真则为真，2个为真则为假 00110001

printf('wA ^ wB=？%d ', wA ^ wB);

printf('~wB=？%d ', ~wB);

//二进制左移运算符 左 * 4 = 40

printf('wC<<2=？%d ', wC << 2);

//二进制右移运算符 右 / 4

printf('wC>>2=？%d ', wC >> 2);

}

输出：

wA & wB=？12

wA | wB=？61

wA ^ wB=？49

~wB=？-14

wC<<2=？40

wC>>2=？2

下表显示了 C 语言支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

赋值运算符

下表列出了 C 语言支持的赋值运算符：

例子：

void main(){

int wAA = 21;

int wBB;

wBB = wAA;

printf('= %d ', wBB);

wBB += wAA;

printf('+= %d ', wBB);

wBB -= wAA;

printf('-= %d ', wBB);

wBB *= wAA;

printf('*= %d ', wBB);

wBB /= wAA;

printf('/= %d ', wBB);

wBB %= wAA;

printf('%= %d ', wBB);

wBB <<= wAA;

printf('<<= %d ', wBB);

wBB <<= wAA;

printf('>>= %d ', wBB);

wBB &= wAA;

printf('&= %d ', wBB);

wBB ^= wAA;

printf('^= %d ', wBB);

wBB |= wAA;

printf('|= %d ', wBB);

}

输出：

= 21

+= 42

-= 21

*= 441

/= 21

= 0

<<= 0

>>= 0

&= 0

^= 21

|= 21

杂项运算符 sizeof、&、三元

下表列出了 C 语言支持的其他一些重要的运算符，包括 sizeof 和 ? :。

例子：

void main(){

int zxA = 4;

short zxB;

double zxC;

int *ptr;

//sizeOf 运算符实例 ,lu 32位无符号整数

printf('zxA sizeOf = %lu ', sizeof(zxA));

printf('zxB sizeOf = %lu ', sizeof(zxB));

printf('zxC sizeOf = %lu ', sizeof(zxC));

//& 和 * 运算符实例

ptr = &zxA; //将 zxA 的地址值复制给 ptr 指针

printf('zxA 的值为：%d ', zxA);

printf('*ptr 的值为：%d ', *ptr);

//三元运算符

zxA = 10;

zxB = (zxA == 1) ? 20 : 30;

printf('zxb 的值为：%d ', zxB);

zxB = (zxA == 10) ? 20 : 30;

printf('zxb 的值为：%d ', zxB);

}

输出：

zxA sizeOf = 4

zxB sizeOf = 2

zxC sizeOf = 8

zxA 的值为：4

*ptr 的值为：4

zxb 的值为：30

zxb 的值为：20

C 语言把任何非零和非空的值假定为 true，把零或 null 假定为 false。

C 语言提供了以下类型的判断语句。

?:运算符

跟 Java 一样

void main(){

int pdNumber;

printf('输入一个数字：');

scanf('%d', &pdNumber);

(pdNumber % 2 == 0) ? printf('偶数') : printf('基数');

}

C 语言提供了以下几种循环类型。

循环控制语句

循环控制语句改变你代码的执行顺序。通过它你可以实现代码的跳转。

C 提供了下列的循环控制语句。

使用方法可以参考 Java ，下面给出循环的例子:

void main(){

//限制

for (int i = 0; i < 6; i++) {

printf('限制循环,%d ',i);

}

//无限循环

for (;;) {

printf('该循环会一直执行下去！ ');

}

}

函数定义

C 语言中的函数定义的一般形式如下：

return_type function_name( parameter list )

{

body of the function

}

在 C 语言中，函数由一个函数头和一个函数主体组成。下面列出一个函数的所有组成部分：

**返回类型：**一个函数可以返回一个值。return_type是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字void。

**函数名称：**这是函数的实际名称。函数名和参数列表一起构成了函数签名。

**参数：**参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。

**函数主体：**函数主体包含一组定义函数执行任务的语句。

例子：

/* 函数返回两个数中较大的那个数 */

int max(int num1, int num2)

{

/* 局部变量声明 */

int result;

if (num1 > num2)

result = num1;

else

result = num2;

return result;

}

函数声明

函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

函数声明包括以下几个部分：

return_type function_name( parameter list );

针对上面定义的函数 max()，以下是函数声明：

int max(int num1, int num2);

在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明：

int max(int, int);

当您在一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，您应该在调用函数的文件顶部声明函数。

调用函数

//函数声明

int max(int num1, int num2);

/**

*C 函数

*/

void main() {

//找出函数中最大值

printf('找出函数中最大值，%d ',max(66,88));

}

int max(int num1, int num2) {

return (num1 > num2) ? num1 : num2;

}

输出：找出函数中最大值，88

函数参数

如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。

形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。

本节知识将会以分节的形式向大家展示，又想要学习C语言的小伙伴可以关注笔者！一起来加油呀~

自学C/C++编程难度很大，不妨和一些志同道合的小伙伴一起学习成长！

C语言C++编程学习交流圈子，私信【C/C++编程】微信公众号：C语言编程学习基地

有一些源码和资料分享，欢迎转行也学习编程的伙伴，和大家一起交流成长会比自己琢磨更快哦！