当前课程知识点:基于Linux的C++ >  第一讲 C/C++基本语法元素 >  1.3 简单C/C++程序介绍 >  LinuxCPP0103

返回《基于Linux的C++》慕课在线视频课程列表

LinuxCPP0103在线视频

LinuxCPP0103

下一节:LinuxCPP0104

返回《基于Linux的C++》慕课在线视频列表

LinuxCPP0103课程教案、知识点、字幕

现在我们通过一个简单的C程序

来让大家有一个感性认识

注意我这里写的很清楚

是C的程序 不是C++的

我们编写一个程序

显示一个字符串hello World

我们程序代码展示给大家

总共就六行

俩花括号还占两行

所以实际上就四行

看上去很清楚

第一行#include

第二行就是int main()

我们先说第二行

因为这很重要

每一个C和C++的程序都有一个主函数

这个主函数的名字叫做main

名字是固定的 就这么写

main全小写

这就是我们的主函数

这就是这个主函数的函数头

每一个程序就这么一个

必须有一个 只能有一个

除非你写的不是程序

而是C或C++库

那个不需要main

这是我们的主函数

花括号对就表示这个主函数的函数体

里面封装我们的语句序列

对于我们这道题呢

情况很简单

第一条语句是#include

std是标准

io就是input output

叫输入输出

就这意思

.h h就是header 头文件

我们要包含这个头文件

这个是预编译指令

我们要在编译前把它封装进去

然后才能编译

我们要包含这个标准头文件

C标准库里面给我们提供

你直接用就行了

关键是为啥要用这条语句

因为这我们调用了printf

标准库函数

它在我们的输出设备上面输出一行文本

这个输出设备

一般对应我们计算机屏幕

投影仪当然也是输出设备

这行文本可以按照很特殊的格式

来去构造 拼凑 生成

双引号引起来的

“hello World!\n”

称为字符串

“\n”是什么呢

它不是两个字符——一个“\” 一个“n”

它是一个转义字符序列

用来表达输出一个换行

换行这个东西

你在写程序的时候觉得很直接

你按一下Enter就做完了

可是你要在程序运行的时候

输出一个换行可不能这么做

你不能在“Hello World!”后面回车

那个换行是不存在的

换行会变成我们源文件一部分

不是程序执行一部分

所以要想在程序运行的过程中

输出一个换行符

必须用一个转义字符序列

这里就是“\n”

“\”表示转义序列开始

“n”表示产生一个换行

printf是标准库函数

这个函数的函数原型是写在“stdio.h”

这个头文件里面的

你想知道这个函数用的对不对

你必须把这个“stdio.h”文件调出来看

两个对照 才能知道它对不对

我们是这样 编译器也是这样

编译器要知道

我们这个printf函数用的对不对

它必须把头文件调出来

然后两者一对照

才能知道我们用的对不对

其实不仅仅是这样

它还要知道

这个函数入口地址在哪里

没有函数原型

我们就找不到函数入口地址

最后代码是return 0

我的程序做完了 结束了

后面有一个0

表示这个程序做完以后

会带回来一个结果

这个结果必须是整数

我们就传了一个0回来

为什么它必须是一个整数呢

在程序是怎么体现的呢

就是main函数的前面

有一个int这样一个标记

这就表示main函数做完了

它会带来一个结果

这个结果就是这个函数的返回值

返回值是一个整数

那这个整数你说我返回1

return 1、return 2、return -1行不行

行 但是只要你有经验

你一定不会写1、-1这样的数

你一定会写0 为啥呢

因为这个返回值是给操作系统用的

这个结果会传给操作系统

操作系统要根据你传回来这个结果

来决定你这个程序有没有正确执行

有没有错误

如果发生错误 什么性质的错误

我们知道正确执行的路就一条

而错误执行的路是很多条

对吧 这叫什么

幸福的家庭总是相似的

不幸的家庭各有各的不幸

这个也是这样 它发生错误了

错误有很多种

正确执行了 就一种情况

错误执行了 很多种错误

A类错误、B类错误、C类错误、D类错误

那么操作系统怎么区分

它们之间的关系呢

那你写程序就要定义好

A类错误我返回1

B类错误我返回2

C类错误我返回3

然后操作系统就查我的错误返回值

返回1 返回2 返回3

一下不就明白了吗

哦 你这程序发生什么类型的错误

退出值是什么

然后我才能有的放矢去做后续的操作

所以main这个返回值除非发生错误

否则同学们一定要return 0

这是我们简单C程序

现在我们把它写成C++的版本

我们用C++的程序代码

现在几行呢

七行 多了一行

这一行叫using namesapce std

在C++里面

要按照C++格式做输入输出的操作

C++提供了一个全局对象

我们称它为标准输出流

叫cout 我们可以直接用

复杂的输出它其实还不如printf

但简单的输出它比printf方便

因为可以连续地输出

这个东西的定义在哪 在头文件

“iostream”里

所以我们包含这个头文件

头文件后面没有“.h”

这个文件名字就叫“iostream”

早期的C++是有“iostream.h”的

现在新版C++格式后面“.h”都不要了

就叫“iostream”

类似地C程序(的头文件)前面要加一个“c”

比如“stdio.h”

你要想用C++新格式包含它

就要写“cstdio”

后面“.h”就可以不要了

C++引入一个很特殊的东西

我们称它为名空间

英语叫它什么

namespace

这个空间名字叫什么呢

叫std 标准名空间

C++标准库的名字呢

都在标准名空间里

比如cout、endl

都在标准名空间里

和别的名空间是分开的

这是非常重要的一个设计

如果名字太多

全在一个空间里面

重名的话不太好解决啊

现在你可以给这些名字

定义不同的名空间

两个名空间里面名字就可以一样

因为可以通过名空间来解析它们

cout、endl都在这个名空间里

你要想用它你必须写using namespace std

才能够完成这个名解析

如果没有这行语句

就应该写std::cout

std::endl

每个名字前面都要加上名空间的名字

加上“::”

这叫名解析操作符

好麻烦啊

所以我们这里面就写using namespace std

简短的程序我们就这么写

我们用cout来完成标准输出

用“<<” 表达数据流动的方向

你看“<”箭头从哪到哪

开口在右边 箭头在左边

表示数据从右边向左边流动

就这个意思

按照这个格式 继续流

<< endl

把endl这个标记也流到了这个cout里面

end l是什么 叫end line

结束这一行 形成一个换行

就是这个意思

然后return 0结束

这就是很典型的C++程序代码

现在我们来看第二个例子

我们要编写一个程序

来计算用户输入的两个整数之和

这段代码就比刚才要复杂了

我们这道题就需要三个量

一个叫a 一个叫b 一个叫sum

定义就定义在这里

我要定义一个整数数据对象就用int

后面跟着那个变量的名字

如果有很多变量同时定义

中间用逗号来分隔开

我要得到a、b两个量的值

让用户在程序运行的时候输入

我会输出“a: ”

之后光标就在后面闪烁

提醒用户输入一个整数

用户输入这个整数我们怎么得到呢

cin 它和cout一样的

也是全局对象

也是定义在“iosdream”这个头(文件)里

我们称之为标准输入流

通过键盘哗啦哗啦不断往里敲

不管你敲什么东西

它都进入cin

然后我们要把数据一个一个取出来

取一个整数给a

那我们就写cin >> a

就把这个数据从cin这个标准输入流里面

传给这个整形变量a

a就会得到一个整数

如果没有cout

你就直接写cin >> a

然后cin >> b

或者你连写cin >> a >> b

程序本身是没问题的

可以运行

但是你程序什么提示信息都没有

用户压根不知道你要干嘛

这样的格式不妥当

所以每个输入数据理论上来讲

都应该给出一个提示

让用户知道你要求它输入什么

这两个量都输入完

我a加b 赋值给sum

注意这不是真正的等式

我们称它为赋值

那个等号称为赋值号

我们也不应该念成等号

为什么它不是等号呢

讲起来其实很简单的

(对于)数学上的等号

左边调到右边

右边调到左边

是不影响它等式正确性的

你把这个左边和右边对调过来试一试

那是不可能的

我要把a和b两者的值加起来

然后把它的结果传给sum

这个动作是需要耗费时间的

它不是纯粹数学上

和时间完全无关的一个等号

所以它其实不是等号

它叫赋值号

现在我们想得稍微再深入一点

我的main函数里面有三个量

这三个量名字叫a、b、sum

你肯定要保存起来

它方在哪呢

放在我们计算机内存里

所以我划一个方框

来表达存储这个数据的内存区域

在旁边给它贴一个标签

写了一个名字叫a

这个a 注意我不是写在这个框里面的

框里面我应该写什么呢

框里面我写的是这个量

它当时保存的值是多少

a后来得到了1

b后来得到了2

这两个数据就会写在这里

我一求和 sum结果就是3

这就是我们数据实际存储过程

现在对C/C++的程序结构做一个总结

C/C++程序正常情况下由一个

或多个函数组成

其中有一个唯一的主函数

我们称之为main

程序执行的时候

由主函数的第一条语句开始

到主函数的最后一条语句结束

其它的函数都是由主函数

直接和间接调用

整个程序的执行流程

和这些函数它的定义的顺序

是没有关系的

每个函数都包括

函数头和函数体两个部分

C/C++里面包含了大量的库函数

我们都可以直接用

基于Linux的C++课程列表:

第一讲 C/C++基本语法元素

-1.1 提纲

--LinuxCPP0101

-1.2 程序设计的基本概念

--LinuxCPP0102

-1.3 简单C/C++程序介绍

--LinuxCPP0103

-1.4 程序设计的基本流程

--LinuxCPP0104

-1.5 基本语法元素

--LinuxCPP0105

-1.6 程序设计风格

--LinuxCPP0106

-1.7 编程实践

--LinuxCPP0107

-第一讲 C/C++基本语法元素--编程实践提交入口

第二讲 程序控制结构

-2.1 提纲

--LinuxCPP0201

-2.2 结构化程序设计基础

--LinuxCPP0202

-2.3 布尔数据

--LinuxCPP0203

-2.4 分支结构

--LinuxCPP0204

-2.5 break语句

--LinuxCPP0205

-2.6 循环结构

--LinuxCPP0206

-2.7 编程实践

--LinuxCPP0207

-第二讲 程序控制结构--编程实践提交入口

第三讲 函数

-3.1 提纲

--LinuxCPP0301

-3.2 函数声明、调用与定义

--LinuxCPP0302

-3.3 函数调用栈框架

--LinuxCPP0303

-3.4 编程实践

--LinuxCPP0304

-第三讲 函数--编程实践提交入口

第四讲 算法

-4.1 提纲

--LinuxCPP0401

-4.2 算法概念与特征

--LinuxCPP0402

-4.3 算法描述

--LinuxCPP0403

-4.4 算法设计与实现

--LinuxCPP0404

-4.5 递归算法(一)

--LinuxCPP0405

-4.6 递归算法(二)

--LinuxCPP0406

-4.7 容错与计算复杂度

--LinuxCPP0407

-4.8 编程实践

--LinuxCPP0408

-第四讲 算法--编程实践提交入口

第五讲 程序组织与开发方法

-5.1 提纲

--LinuxCPP0501

-5.2 库与接口

--LinuxCPP0502

-5.3 随机数库(一)

--LinuxCPP0503

-5.4 随机数库(二)

--LinuxCPP0504

-5.5 作用域与生存期

--LinuxCPP0505

-5.6 典型软件开发流程(一)

--LinuxCPP0506

-5.7 典型软件开发流程(二)

--LinuxCPP0507

-5.8 编程实践

--LinuxCPP0508

-第五讲 程序组织与开发方法--编程实践提交入口

第六讲 复合数据类型

-6.1 提纲

--LinuxCPP0601

-6.2 字符

--LinuxCPP0602

-6.3 数组(一)

--LinuxCPP0603

-6.4 数组(二)

--LinuxCPP0604

-6.5 结构体

--LinuxCPP0605

-6.6 编程实践

--LinuxCPP0606

-第六讲 复合数据类型--编程实践提交入口

第七讲 指针与引用

-7.1 提纲

--LinuxCPP0701

-7.2 指针基本概念

--LinuxCPP0702

-7.3 指针与函数

--LinuxCPP0703

-7.4 指针与复合数据类型(一)

--LinuxCPP0704

-7.5 指针与复合数据类型(二)

--LinuxCPP0705

-7.6 字符串

--LinuxCPP0706

-7.7 动态存储管理(一)

--LinuxCPP0707

-7.8 动态存储管理(二)

--LinuxCPP0708

-7.9 引用

--LinuxCPP0709

-7.10 编程实践

--LinuxCPP0710

-第七讲 指针与引用--编程实践提交入口

第八讲 链表与程序抽象

-8.1 提纲

--LinuxCPP0801

-8.2 数据抽象(一)

--LinuxCPP0802

-8.3 数据抽象(二)

--LinuxCPP0803

-8.4 链表(一)

--LinuxCPP0804

-8.5 链表(二)

--LinuxCPP0805

-8.6 链表(三)

--LinuxCPP0806

-8.7 链表(四)

--LinuxCPP0807

-8.8 函数指针(一)

--LinuxCPP0808

-8.9 函数指针(二)

--LinuxCPP0809

-8.10 抽象链表(一)

--LinuxCPP0810

-8.11 抽象链表(二)

--LinuxCPP0811

-8.12 编程实践

--LinuxCPP0812

-第八讲 链表与程序抽象--编程实践提交入口

第九讲 类与对象

-9.1 提纲

--LinuxCPP0901

-9.2 程序抽象与面向对象

--LinuxCPP0902

-9.3 类类型

--LinuxCPP0903

-9.4 对象(一)

--LinuxCPP0904

-9.5 对象(二)

--LinuxCPP0905

-9.6 类与对象的成员(一)

--LinuxCPP0906

-9.7 类与对象的成员(二)

--LinuxCPP0907

-9.8 类与对象的成员(三)

--LinuxCPP0908

-9.9 继承(一)

--LinuxCPP0909

-9.10 继承(二)

--LinuxCPP0910

-9.11 继承(三)

--LinuxCPP0911

-9.12 多态(一)

--LinuxCPP0912

-9.13 多态(二)

--LinuxCPP0913

-9.14 编程实践

--LinuxCPP0914

-第九讲 类与对象--编程实践提交入口

第十讲 操作符重载

-10.1 提纲

--LinuxCPP1001

-10.2 四则运算符重载(一)

--LinuxCPP1002

-10.3 四则运算符重载(二)

--LinuxCPP1003

-10.4 关系与下标操作符重载

--LinuxCPP1004

-10.5 赋值操作符重载(一)

--LinuxCPP1005

-10.6 赋值操作符重载(二)

--LinuxCPP1006

-10.7 赋值操作符重载(三)

--LinuxCPP1007

-10.8 赋值操作符重载(四)

--LinuxCPP1008

-10.9 赋值操作符重载(五)

--LinuxCPP1009

-10.10 流操作符重载(一)

--LinuxCPP1010

-10.11 流操作符重载(二)

--LinuxCPP1011

-10.12 流操作符重载(三)

--LinuxCPP1012

-10.13 操作符重载总结

--LinuxCPP1013

-10.14 编程实践

--LinuxCPP1014

-第十讲 操作符重载--编程实践提交入口

第十一讲 泛型编程

-11.1 提纲

--LinuxCPP1101

-11.2 泛型编程概览

--LinuxCPP1102

-11.3 异常处理机制(一)

--LinuxCPP1103

-11.4 异常处理机制(二)

--LinuxCPP1104

-11.5 运行期型式信息(一)

--LinuxCPP1105

-11.6 运行期型式信息(二)

--LinuxCPP1106

-11.7 模板与型式参数化

--LinuxCPP1107

-11.8 题外话:术语翻译

--LinuxCPP1108

-11.9 泛型编程实践(一)

--LinuxCPP1109

-11.10 泛型编程实践(二)

--LinuxCPP1110

-11.11 泛型编程实践(三)

--LinuxCPP1111

-11.12 泛型编程实践(四)

--LinuxCPP1112

-11.13 泛型编程实践(五)

--LinuxCPP1113

-11.14 泛型编程实践(六)

--LinuxCPP1114

-11.15 泛型编程实践(七)

--LinuxCPP1115

-11.16 泛型编程实践(八)

--LinuxCPP1116

-11.17 泛型编程实践(九)

--LinuxCPP1117

-11.18 泛型编程实践(十)

--LinuxCPP1118

-11.19 编程实践

--LinuxCPP1119

-第十一讲 泛型编程--编程实践提交入口

第十二讲 Linux系统编程基础

-12.1 提纲

--LinuxCPP1201

-12.2 程序执行环境(一)

--LinuxCPP1202

-12.3 程序执行环境(二)

--LinuxCPP1203

-12.4 程序执行环境(三)

--LinuxCPP1204

-12.5 程序执行环境(四)

--LinuxCPP1205

-12.6 输入输出(一)

--LinuxCPP1206

-12.7 输入输出(二)

--LinuxCPP1207

-12.8 文件系统

--LinuxCPP1208

-12.9 设备

--LinuxCPP1209

-12.10 库(一)

--LinuxCPP1210

-12.11 库(二)

--LinuxCPP1211

-12.12 makefile文件(一)

--LinuxCPP1212

-12.13 makefile文件(二)

--LinuxCPP1213

-12.14 makefile文件(三)

--LinuxCPP1214

-12.15 编程实践

--LinuxCPP1215

-第十二讲 Linux系统编程基础--编程实践提交入口

第十三讲 进程编程

-13.01 提纲

--LinuxCPP1301

-13.02 进程基本概念

--LinuxCPP1302

-13.03 信号

--LinuxCPP1303

-13.04 进程管理(一)

--LinuxCPP1304

-13.05 进程管理(二)

--LinuxCPP1305

-13.06 进程管理(三)

--LinuxCPP1306

-13.07 进程间通信(一)

--LinuxCPP1307

-13.08 进程间通信(二)

--LinuxCPP1308

-13.09 进程间通信(三)

--LinuxCPP1309

-13.10 进程间通信(四)

--LinuxCPP1310

-13.11 进程池

--LinuxCPP1311

-13.12 编程实践

--LinuxCPP1312

-第十三讲 进程编程--编程实践提交入口

第十四讲 线程编程

-14.1 提纲

--LinuxCPP1401

-14.2 线程基本概念

--LinuxCPP1402

-14.3 线程管理(一)

--LinuxCPP1403

-14.4 线程管理(二)

--LinuxCPP1404

-14.5 线程管理(三)

--LinuxCPP1405

-14.6 线程管理(四)

--LinuxCPP1406

-14.7 线程同步机制(一)

--LinuxCPP1407

-14.8 线程同步机制(二)

--LinuxCPP1408

-14.9 C++11线程库(一)

--LinuxCPP1409

-14.10 C++11线程库(二)

--LinuxCPP1410

-14.11 C++11线程库(三)

--LinuxCPP1411

-14.12 C++11线程库(四)

--LinuxCPP1412

-14.13 C++11线程库(五)

--LinuxCPP1413

-14.14 编程实践

--LinuxCPP1414

-第十四讲 线程编程--编程实践提交入口

第十五讲 网络编程

-15.1 提纲

--LinuxCPP1501

-15.2 Internet网络协议

--LinuxCPP1502

-15.3 套接字(一)

--LinuxCPP1503

-15.4 套接字(二)

--LinuxCPP1504

-15.5 编程实践

--LinuxCPP1505

-第十五讲 网络编程--编程实践提交入口

课程文档

-课程PDF文件

LinuxCPP0103笔记与讨论

也许你还感兴趣的课程:

© 柠檬大学-慕课导航 课程版权归原始院校所有,
本网站仅通过互联网进行慕课课程索引,不提供在线课程学习和视频,请同学们点击报名到课程提供网站进行学习。