音像学习 (I) C 语言入门
前言
现在 Android 初中级开发工程师想找一份满意的工作是越来越难了,当然有实力的是不愁好工作的。如果正巧你是初中级工程师想要进阶音视频方向或者对 NDK 技术感兴趣的,那么关注我准没错。在 5G 时代的到来,我相信音视频方向的工程师会越来越吃香。那么想要学习音视频技术首先就得具备 C/C++ 语言基础,下面我们就先来学习 C 语言基础。
ps: 音视频方向计划写一个系列文章 (初步计划以 C/C++ 语言基础、JNI 、Makefile/Cmake 、利用 FFmpeg 开发音视频播放器 、RTMP 直播、OpenCV 人脸/车牌识别、OpenGL 视频处理、视频特效、WebRTC 音视频通话等技术文章),该系列我也会持续更新 。C/C++ 基础文章本来我是不打算写的,看过我的文章都知道我写的几乎是系列文章,如果缺胳膊少腿的看起来也不那么清晰流程,所以 C/C++ 基础我就参考网上的来写了,因为基础这个东西,网上好的入门资料太多了,该篇就当复习参考了。有这方面基础的可以直接翻篇了????。
就不说那么多废话了,下面我们就一起来学习音视频方向的技术,让我们一起沉浸在学习中无法自拔????。
C 简介
C 语言是一种通用的高级语言,最初是由丹尼斯·里奇在贝尔实验室为开发 UNIX 操作系统而设计的。C 语言最开始是于 1972 年在 DEC PDP-11 计算机上被首次实现。
在 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 语言入门
不知道大家在学习一门新的开发语言敲的第一行代码是什么?应该百分之 90 % 以上都是打印 ”HelloWorld“ 吧,我们就以打印 ”HelloWorld“ 为例来正式进入 C 语言的学习吧。
1. 程序结构
我们先来看一下最简单的一个 C 程序,先来打印一个 “HelloWorld”。代码如下:
#include <stdio.h>
/**
* C 语言入口程序
* @return
*/
int main() {//主函数,程序从这里开始执行
printf("C 语言入门第一行代码 Hello World! \n");
return 0;
}
可以看到 C 语言的入口函数跟 Java 的类似吧,都是以 main
来定义的入口,接下来我们讲解一下上面这段程序的意思:
- 程序的第一行 #include <stdio.h> 是预处理器指令,告诉 C 编译器在实际编译之前要包含 stdio.h 文件。
- 下一行 /.../ 将会被编译器忽略,这里放置程序的注释内容。它们被称为程序的注释。
- 下一行 int main() 是主函数,程序从这里开始执行。
- 下一行 printf(...) 是 C 中另一个可用的函数,会在屏幕上显示消息 "C 语言入门第一行代码 Hello World!"。
- 下一行 return 0; 终止 main() 函数,并返回值 0。
当然你可以通过命令来执行,如下所示:
1. 使用 gcc xxx.c
2. ./a.out
直接使用上面 2 个步骤就可以进行执行 C 代码了。
2. 基本语法
上一小节我们知道了一个简单的小应用由哪些部分组成,这将有助于我们理解 C 语言的其它基本的构建块。
c 程序由各种令牌组成,令牌可以是关键字、标识符、常量、字串符值、或者是一个符号。
下面我们来看一下 C 中的关键字,这些关键字不能作为常量名,变量名或者其它标识符名称(跟 Java 类似)。
关键字 | 说明 |
---|---|
auto | 声明自动变量 |
break | 跳出当前循环 |
case | 开关语句分支 |
char | 声明字符型变量或者函数返回值类型 |
const | 声明只具可读变量 |
continue | 结束当前循环,开始下一个循环 |
default | 开关语句中的其它分支 |
do | 循环语句的循环体 |
double | 声明双进度浮点型变量或者函数返回值类型 |
else | 条件语句否定分支 |
enum | 声明枚举类型 |
extern | 声明变量或函数是在其它文件或本文件的其他位置定义 |
float | 声明浮点型变量或者函数返回值类型 |
for | 一种循环语句 |
goto | 无条件跳转语句 |
if | 条件语句 |
int | 声明整型变量或函数 |
long | 声明长整型变量或函数返回值类型 |
register | 声明寄存器变量 |
return | 子程序返回语句 |
short | 声明短整型变量或者函数 |
signed | 声明有符号类型变量或者函数 |
sizeof | 计算数据类型或者变量长度(即所占字节数) |
static | 声明静态变量 |
struct | 声明结构体类型 |
switch | 用于开关语句 |
typedef | 用以给数据类型取别名 |
unsigned | 声明无符号类型变量或函数 |
union | 声明共用体类型 |
void | 声明函数无返回值或无参树,声明无类型指针 |
volatile | 说明变量在程序执行中可被隐含地改变 |
while | 循环语句的循环条件 |
3. 数据类型
在 C 语言中,数据类型指的是用于声明不同类型的变量或函数的一个广泛的系统。变量的类型决定了变量存储占用的空间,以及如何解释存储的位模式。
C 中的类型可分为以下几种:
类型 | 说明 |
---|---|
基本类型 | 它们是算术类型,包括两种类型:整数类型和浮点类型。 |
枚举类型 | 它们也是算术类型,被用来定义在程序中只能赋予其一定的离散整数值得变量。 |
void 类型 | 类型说明符 void 表名没有可用的值 |
派生类型 | 它们包括:指针类型、数组类型、结构类型、共用体类型和函数类型。 |
整数类型
下表列出了关于标准整数类型的存储大小和值范围的细节
类型 | 32 位 | 64 位 | 值范围 |
---|---|---|---|
char | 1 | 1 | -128 到 127 或 0 到 255 |
unsigned char | 1 | 1 | 0 到 255 |
int | 4 | 4 | -32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647 |
unsigned int | 4 | 4 | 0 到 65,535 或 0 到 4,294,967,295 |
short | 2 | 2 | -32,768 到 32,767 |
unsigned short | 2 | 2 | 0 到 65,535 |
long | 4 | 8 | -2,147,483,648 到 2,147,483,647 |
unsigned long | 4 | 8 | 0 到 4,294,967,295 |
注意:
各种类型的存储大小与系统位数有关,但目前通用的以 64 为系统为主。
浮点类型
类型 | 比特(位)数 | 有效数字 | 取值范围 |
---|---|---|---|
float | 4 | 6~7 | 1.2E-38 到 3.4E+38 |
double | 8 | 15~16 | 2.3E-308 到 1.7E+308 |
long double | 16 | 18~19 | 3.4E-4932 到 1.1E+4932 |
他们的字节,精度,取值范围都可以通过代码打印实现,如下:
void main() {
/**
* 整数类型
*/
printf("\n\n 整数类型 \n");
//char 1 字节
printf("char 存储大小: %lu \n", sizeof(char));
printf("unsinged char 存储大小: %lu \n", sizeof(unsigned char));
//short 2 字节
printf("short 存储大小: %lu \n", sizeof(short));
printf("unsinged short 存储大小: %lu \n", sizeof(unsigned short));
//int 4 字节
printf("int 存储大小: %lu \n", sizeof(int));
printf("unsinged int 存储大小: %lu \n", sizeof(unsigned int));
//long 4/8 字节
printf("long 存储大小: %lu \n", sizeof(long));
printf("unsinged long 存储大小: %lu \n", sizeof(unsigned long));
/**
* 浮点类型
*/
printf("\n\n 浮点类型 \n");
//float 4 字节 ,精度 6 位小数
printf("float 存储最大字节数:%lu \n", sizeof(float));
printf("float 最小值:%e \n", FLT_MIN);
printf("float 最大值:%e \n", FLT_MAX);
printf("float 精度值:%d \n", FLT_DIG);
//double 8 字节
printf("double 存储最大字节数:%d \n", sizeof(double));
printf("double 最小值:%e \n", DBL_MIN);
printf("double 最大值:%e \n", DBL_MAX);
printf("double 精度值:%d \n", DBL_DIG);
//long double 16 字节
printf("long double 存储最大字节数:%lu byte \n", sizeof(long double));
printf("long double 最小值:%lg \n", LDBL_MIN);
printf("long double 最大值:%lg \n", LDBL_MAX);
printf("long double 精度值:%d \n", LDBL_DIG);
}
可以通过 sizeof
关键字来获取数据类型占用内存的大小。上面代码可以看到了打印中出现了很多不识的 scanf() 格式控制符,我总结了一个表,可以参考下:
格式控制符 | 说明 |
---|---|
%c | 读取一个单一的字符 |
%hd、%d、%ld | 读取一个十进制整数,并分别赋值给 short、int、long 类型 |
%ho、%o、%lo | 读取一个八进制整数(可带前缀也可不带),并分别赋值给 short、int、long 类型 |
%hx、%x、%lx | 读取一个十六进制整数(可带前缀也可不带),并分别赋值给 short、int、long 类型 |
%hu、%u、%lu | 读取一个无符号整数,并分别赋值给 unsigned short、unsigned int、unsigned long 类型 |
%f、%lf | 读取一个十进制形式的小数,并分别赋值给 float、double 类型 |
%e、%le | 读取一个指数形式的小数,并分别赋值给 float、double 类型 |
%g、%lg | 既可以读取一个十进制形式的小数,也可以读取一个指数形式的小数,并分别赋值给 float、double 类型 |
%s | 读取一个字符串(以空白符为结束) |
4. 变量
变量其实只不过是程序可操作的存储区的名称。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 可以在别的文件中定义的。
- 除非有 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
5. 常量
常量是固定值,在程序执行期间不会改变。这些固定的值,又叫做字面量。
常量可以是任何的基本数据类型,比如整数常量、浮点常量、字符常量,或字符串字面值,也有枚举常量。
常量就像是常规的变量,只不过常量的值在定义后不能进行修改。
在 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 = '\n';
int area;
area = LEGTH * WIDTH;
printf("value of area: %d", area);
}
6. 存储类
存储类定义 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 \n", 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 头文件
//
// Created by 阳坤 on 2019/12/13.
//
#ifndef NDK_SAMPLE_SUPPORT_H
#define NDK_SAMPLE_SUPPORT_H
#endif //NDK_SAMPLE_SUPPORT_H
extern int add(int num1,int num2);
头文件的实现 support.c
int add(int num1,int num2){
return num1 * num2;
}
输出:
extern 使用 :10
7. 运算符
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C 语言内置了丰富的运算符,并提供了以下类型的运算符:
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 杂项运算符
算术运算符
下表显示了 C 语言支持的所有算术运算符。假设变量 A 的值为 10,变量 B 的值为 20,则:
运算符 | 描述 | 实例 |
---|---|---|
+ | 把两个操作数相加 | A + B 将得到 30 |
- | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
* | 把两个操作数相乘 | A * B 将得到 200 |
/ | 分子除以分母 | B / A 将得到 2 |
% | 取模运算符,整除后的余数 | B % A 将得到 0 |
++ | 自增运算符,整数值增加 1 | A++ 将得到 11 |
-- | 自减运算符,整数值减少 1 | A-- 将得到 9 |
例子:
void main(){
int a = 21;
int b = 10;
int c;
c = a + b;
printf("a + b = %d \n", c);
c = a - b;
printf("a - b = %d \n", c);
c = a * b;
printf("a * b = %d \n", c);
c = a / b;
printf("a / b = %d \n", c);
c = a % b;
printf("a % b = %d \n", c);
c = ++a;
printf("++a = %d , %d \n", c, a);
c = b++;
printf("b++ = %d , %d \n", c, b);
c = b--;
printf("b-- = %d \n", 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,则:
运算符 | 描述 | 实例 |
---|---|---|
== | 检查两个操作数的值是否相等,如果相等则条件为真。 | (A == B) 为假。 |
!= | 检查两个操作数的值是否相等,如果不相等则条件为真。 | (A != B) 为真。 |
> | 检查左操作数的值是否大于右操作数的值,如果是则条件为真。 | (A > B) 为假。 |
< | 检查左操作数的值是否小于右操作数的值,如果是则条件为真。 | (A < B) 为真。 |
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是则条件为真。 | (A >= B) 为假。 |
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是则条件为真。 | (A <= B) 为真。 |
逻辑运算符
下表显示了 C 语言支持的所有关系逻辑运算符。假设变量 A 的值为 1,变量 B 的值为 0,则:
运算符 | 描述 | 实例 |
---|---|---|
&& | 称为逻辑与运算符。如果两个操作数都非零,则条件为真。 | (A && B) 为假。 |
|| | 称为逻辑或运算符。如果两个操作数中有任意一个非零,则条件为真。 | (A || B) 为真。 |
! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(A && B) 为真。 |
void main(){
int a1 = 5;
int b1 = 5;
int c1;
//如果两个操作数都非零,则条件为真。
if (a1 && b1) {
printf("a1 && b1 %d \n", true);
} else {
printf("a1 && b1 %d \n", false);
}
//如果两个操作数中有任意一个非零,则条件为真。
if (a1 || b1) {
printf("a1 || b1 %d \n", true);
} else {
printf("a1 || b1 %d \n", false);
}
//改变 a1 b1 的值
a1 = 0;
b1 = 10;
//如果两个操作数都非零,则条件为真。
if (a1 && b1) {
printf("a1 && b1 %d \n", true);
} else {
printf("a1 && b1 %d \n", false);
}
if (!(a1 && b1)) {
printf("!(a1 && b1) %d \n", true);
} else {
printf("a1 || b1 %d \n", false);
}
}
输出:
a1 && b1 1
a1 || b1 1
a1 && b1 0
!(a1 && b1) 1
位运算符
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
void main(){
//位运算符 & | ^ ~
int wA = 60; //0011 1100
int wB = 13; //0000 1101
int wC = 10;
//都为真,才是真 0000 1100
printf("wA & wB=?%d\n", wA & wB);
//其中一个为真,就为真 0011 1101
printf("wA | wB=?%d\n", wA | wB);
//一个为真则为真,2个为真这为假 00110001
printf("wA ^ wB=?%d\n", wA ^ wB);
printf("~wB=?%d\n", ~wB);
//二进制左移运算符 左 * 4 = 40
printf("wC<<2=?%d\n", wC << 2);
//二进制右移运算符 右 / 4
printf("wC>>2=?%d\n", wC >> 2);
}
输出:
wA & wB=?12
wA | wB=?61
wA ^ wB=?49
~wB=?-14
wC<<2=?40
wC>>2=?2
下表显示了 C 语言支持的位运算符。假设变量 A 的值为 60,变量 B 的值为 13,则:
运算符 | 描述 | 实例 |
---|---|---|
& | 按位与操作,按二进制位进行"与"运算。运算规则:0&0=0; 0&1=0; 1&0=0; 1&1=1;
|
(A & B) 将得到 12,即为 0000 1100 |
| | 按位或运算符,按二进制位进行"或"运算。运算规则:0|0=0; 0|1=1; 1|0=1; 1|1=1;
|
(A | B) 将得到 61,即为 0011 1101 |
^ | 异或运算符,按二进制位进行"异或"运算。运算规则:0^0=0; 0^1=1; 1^0=1; 1^1=0;
|
(A ^ B) 将得到 49,即为 0011 0001 |
~ | 取反运算符,按二进制位进行"取反"运算。运算规则:~1=0; ~0=1;
|
(~A ) 将得到 -61,即为 1100 0011,一个有符号二进制数的补码形式。 |
<< | 二进制左移运算符。将一个运算对象的各二进制位全部左移若干位(左边的二进制位丢弃,右边补0)。 | A << 2 将得到 240,即为 1111 0000 |
>> | 二进制右移运算符。将一个数的各二进制位全部右移若干位,正数左补0,负数左补1,右边丢弃。 | A >> 2 将得到 15,即为 0000 1111 |
赋值运算符
下表列出了 C 语言支持的赋值运算符:
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符,把右边操作数的值赋给左边操作数 | C = A + B 将把 A + B 的值赋给 C |
+= | 加且赋值运算符,把右边操作数加上左边操作数的结果赋值给左边操作数 | C += A 相当于 C = C + A |
-= | 减且赋值运算符,把左边操作数减去右边操作数的结果赋值给左边操作数 | C -= A 相当于 C = C - A |
*= | 乘且赋值运算符,把右边操作数乘以左边操作数的结果赋值给左边操作数 | C *= A 相当于 C = C * A |
/= | 除且赋值运算符,把左边操作数除以右边操作数的结果赋值给左边操作数 | C /= A 相当于 C = C / A |
%= | 求模且赋值运算符,求两个操作数的模赋值给左边操作数 | C %= A 相当于 C = C % A |
<<= | 左移且赋值运算符 | C <<= 2 等同于 C = C << 2 |
>>= | 右移且赋值运算符 | C >>= 2 等同于 C = C >> 2 |
&= | 按位与且赋值运算符 | C &= 2 等同于 C = C & 2 |
^= | 按位异或且赋值运算符 | C ^= 2 等同于 C = C ^ 2 |
|= | 按位或且赋值运算符 | C |= 2 等同于 C = C | 2 |
例子:
void main(){
int wAA = 21;
int wBB;
wBB = wAA;
printf("= %d\n", wBB);
wBB += wAA;
printf("+= %d\n", wBB);
wBB -= wAA;
printf("-= %d\n", wBB);
wBB *= wAA;
printf("*= %d\n", wBB);
wBB /= wAA;
printf("/= %d\n", wBB);
wBB %= wAA;
printf("%= %d\n", wBB);
wBB <<= wAA;
printf("<<= %d\n", wBB);
wBB <<= wAA;
printf(">>= %d\n", wBB);
wBB &= wAA;
printf("&= %d\n", wBB);
wBB ^= wAA;
printf("^= %d\n", wBB);
wBB |= wAA;
printf("|= %d\n", wBB);
}
输出:
= 21
+= 42
-= 21
*= 441
/= 21
= 0
<<= 0
>>= 0
&= 0
^= 21
|= 21
杂项运算符 sizeof、&、三元
下表列出了 C 语言支持的其他一些重要的运算符,包括 sizeof 和 ? :。
运算符 | 描述 | 实例 |
---|---|---|
sizeof() | 返回变量的大小。 | sizeof(a) 将返回 4,其中 a 是整数。 |
& | 返回变量的地址。 | &a; 将给出变量的实际地址。 |
* | 指向一个变量。 | *a; 将指向一个变量。 |
? : | 条件表达式 | 如果条件为真 ? 则值为 X : 否则值为 Y |
例子:
void main(){
int zxA = 4;
short zxB;
double zxC;
int *ptr;
//sizeOf 运算符实例 ,lu 32位无符号整数
printf("zxA sizeOf = %lu \n", sizeof(zxA));
printf("zxB sizeOf = %lu \n", sizeof(zxB));
printf("zxC sizeOf = %lu \n", sizeof(zxC));
//& 和 * 运算符实例
ptr = &zxA; //将 zxA 的地址值复制给 ptr 指针
printf("zxA 的值为:%d \n", zxA);
printf("*ptr 的值为:%d \n", *ptr);
//三元运算符
zxA = 10;
zxB = (zxA == 1) ? 20 : 30;
printf("zxb 的值为:%d \n", zxB);
zxB = (zxA == 10) ? 20 : 30;
printf("zxb 的值为:%d \n", zxB);
}
输出:
zxA sizeOf = 4
zxB sizeOf = 2
zxC sizeOf = 8
zxA 的值为:4
*ptr 的值为:4
zxb 的值为:30
zxb 的值为:20
8. 判断
C 语言把任何非零和非空的值假定为 true,把零或 null 假定为 false。
C 语言提供了以下类型的判断语句。点击链接查看每个语句的细节。
语句 | 描述 |
---|---|
if 语句 | 一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。 |
if...else 语句 | 一个 if 语句 后可跟一个可选的 else 语句,else 语句在布尔表达式为假时执行。 |
嵌套 if 语句 | 您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。 |
switch 语句 | 一个 switch 语句允许测试一个变量等于多个值时的情况。 |
嵌套 switch 语句 | 您可以在一个 switch 语句内使用另一个 switch 语句。 |
?:运算符
跟 Java 一样
void main(){
int pdNumber;
printf("输入一个数字:");
scanf("%d", &pdNumber);
(pdNumber % 2 == 0) ? printf("偶数") : printf("基数");
}
9. 循环
C 语言提供了以下几种循环类型。点击链接查看每个类型的细节。
循环类型 | 描述 |
---|---|
while 循环 | 当给定条件为真时,重复语句或语句组。它会在执行循环主体之前测试条件。 |
for 循环 | 多次执行一个语句序列,简化管理循环变量的代码。 |
do...while 循环 | 除了它是在循环主体结尾测试条件外,其他与 while 语句类似。 |
嵌套循环 | 您可以在 while、for 或 do..while 循环内使用一个或多个循环。 |
循环控制语句
循环控制语句改变你代码的执行顺序。通过它你可以实现代码的跳转。
C 提供了下列的循环控制语句。点击链接查看每个语句的细节。
控制语句 | 描述 |
---|---|
break 语句 | 终止循环或 switch 语句,程序流将继续执行紧接着循环或 switch 的下一条语句。 |
continue 语句 | 告诉一个循环体立刻停止本次循环迭代,重新开始下次循环迭代。 |
goto 语句 | 将控制转移到被标记的语句。但是不建议在程序中使用 goto 语句。 |
使用方法可以参考 Java ,下面给出循环的例子:
void main(){
//限制
for (int i = 0; i < 6; i++) {
printf("限制循环,%d \n",i);
}
//无限循环
for (;;) {
printf("该循环会一直执行下去!\n");
}
}
10. 函数
函数定义
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 \n",max(66,88));
}
int max(int num1, int num2) {
return (num1 > num2) ? num1 : num2;
}
输出:
找出函数中最大值,88
函数参数
如果函数要使用参数,则必须声明接受参数值的变量。这些变量称为函数的形式参数。
形式参数就像函数内的其他局部变量,在进入函数时被创建,退出函数时被销毁。
调用类型 | 描述 |
---|---|
传值调用 | 该方法把参数的实际值复制给函数的形式参数。在这种情况下,修改函数内的形式参数不会影响实际参数。 |
引用调用 | 通过指针传递方式,形参为指向实参地址的指针,当对形参的指向操作时,就相当于对实参本身进行的操作。 |
11. 作用域规则
任何一种编程中,作用域是程序中定义的变量所存在的区域,超过该区域变量就不能被访问。C 语言中有三个地方可以声明变量:
- 在函数或块内部的局部变量
- 在所有函数外部的全局变量
- 在形式参数的函数参数定义中
让我们来看看什么是局部变量、全局变量和形式参数。
局部变量
在某个函数或块的内部声明的变量称为局部变量。它们只能被该函数或该代码块内部的语句使用。局部变量在函数外部是不可知的。下面是使用局部变量的实例。在这里,所有的变量 a、b 和 c 是 main() 函数的局部变量。
void main(){
//局部变量
int a, b;
int c;
//初始化局部变量
a = 10;
b = 20;
c = a + b;
//%d:以十进制形式输出带符号整数(正数不输出符号)
printf("values of a = %d,b = %d and c = %d \n", a, b, c);
}
输出:
values of a = 10,b = 20 and c = 30
全局变量
全局变量是定义在函数外部,通常是在程序的顶部。全局变量在整个程序生命周期内都是有效的,在任意的函数内部能访问全局变量。
全局变量可以被任何函数访问。也就是说,全局变量在声明后整个程序中都是可用的。下面是使用全局变量和局部变量的实例:
//全局变量声明
int g;
void main(){
int a, b;
//初始化局部变量
a = 10;
b = 20;
//全部变量赋值
g = a + c;
printf("values of a = %d,bc = %d and g = %d \n", a, c, g);
}
输出:
values of a = 10,bc = 30 and g = 40
形式参数
函数的参数,形式参数,被当作该函数内的局部变量,如果与全局变量同名它们会优先使用。下面是一个实例:
int sumA(int a, int b) {
printf("value of a in sum() = %d\n", a);
printf("value of b in sum() = %d\n", b);
return x + y;
}
void main(){
int a, b,c;
//初始化局部变量
a = 10;
b = 20;
c = sumA(a, b);
printf("value of c in main() = %d\n", c);
}
输出:
value of a
下一篇: 如何系统地学习 C(上)的基本部分