C++基础

近年来，编程的重要性已成为越来越多的国际意识的主题，从“极客”的狭隘领域扩展到包括K-12教育领域在内的更广阔的世界。从美国在学校强制推行计算机程序设计教育，到全球范围内兴起“每天编程一小时”活动，再到我国教育部公布《2019年教育信息化和网络安全工作要点》，其中指出：今年将启动中小学生信息素养测评，并推动在中小学阶段设置人工智能相关课程，逐步推广编程教育。对于我们普通人来说，编程的能力也正在凸显出前所未有的重要性。

在琳达·卢卡斯的演讲中，她认为“编程就是一个表达自我的方式”。当她了解到，父母可以很轻松的向孩子解释人体的生理构造如何运作，却无法回答关于电脑如何运作的问题。因为不少人也对计算机不够了解，他们“离开精美的用户界面后就不知道如何与计算机交流”。但是演讲者告诉大家，计算机科学并非深奥难懂的学科，反而生活中处处有计算机科学。

教育部于2017年底正式公布了《普通高中信息技术课程标准（2017年版）》，新的课程标准将原来从知识与技能、过程与方法、情感态度与价值观三个维度描述的目标进行了整合，凝练为信息技术学科的四大核心素养：信息意识、计算思维、数字化学习与创新、信息社会责任。计算思维是计算机科学领域的思想方法，是学科本质的体现，是形成问题解决方案的过程中产生的一系列思维活动。

学科核心大概念是学科知识体系的关键核心，有别于学科核心素养指向人的能力、品格与价值观，核心大概念指向知识结构本身。新课程标准明确指出了信息技术学科的四个核心大概念，分别是数据、算法、信息系统、信息社会。其中算法是对特定问题求解步骤的一种描述，是一系列解决问题的清晰指令，精确的算法是计算工具有效计算的前提条件，也是编程的具体指导方法。由此可见，算法指导下的编程是借助计算思维解决问题的一种重要手段。

编程不经意间变得流行起来。越来越多的人发现学会编程是必不可少的，尤其是对年轻一代来说。在一个借助互联网在几毫秒内搜索任何问题答案的世界中，对于学生来说必备的技能不再仅限于传统知识的学习能力。有很多能让人成功的技巧，而这套技能必须包括编程。

一、编程是数字时代的基本素养

当今是一个技术日新月异的时代，要适应这个时代，首先需要知道如何使用这些技术。而要更好地使用这些技术，还需要了解技术背后的逻辑。学习编程时，我们能够理解并摆弄自己所居住的数字世界。编程使技术看起来更像是“魔法”，我们就能够真正理解并控制这项技术的逻辑——只有这样这一过程才更具有魔力。

我们对技术的依赖只会增加。今天的青年一代不仅仅是能够被动地使用新技术，而且要能够理解和控制它，成为这个巨大数字转变的积极组成部分。

二、编程可以改变世界

我们已经看到生活中编程的成果正在改变世界。当互联网开始将当代人的生活由“日用品"变成“必需品"，越来越多的人意识到“编程可以改变世界"。编程是最直接的智力高质转换。通过编程计算机语言，一个人在棋牌等娱乐竞技中体现出的智慧也能够转化为具有实际应用价值和产业价值的输出。

编程是为了自己的世界，可以构造和完善自己的世界。AI时代的编程，拥有大量的接口和配件，我们可以根据自己的想象来构建和完善自己的世界。有的编程语言是为了改变世界，所以它复杂而庞大，有的编程语言是为了改变生活，所以我们的编程工作简约而又优美。我们可以制作各种小家电，可以编程实现各种小应用工具，还可以编程丰富娱乐生活。

三、借助编程让创新想法落地

“你为下一个巨大创新有一个想法？太棒了！你怎么落地？”。每个人都有想法，只有少数人能付诸实践让创意成为现实。编程的能力将那些只有想法的人与能把想法付诸实践的人分开。

目前风靡全球的创客运动，就是鼓励人们将个人的想法积极付诸实践。而在实践的过程中不经意就会涉及大量综合学科内容，其中编程往往不可缺少，也是重要的工具。

如果你想成为一个能给生活带来灵感的思考者和创新者，鼓励自己并加入到学习编程的队伍中来吧。编程让你相信自己可以成为设计师和建设者。

四、编程更是对思维的训练

乔布斯说：“每个人都应该花一点时间学习编程，因为一个学过编程的人，他有一种独特的角度去思考世界”。

任何一个程序中都不是相互分割无关的数据组成，相反，一个程序中会存在很多“重复”内容。比如，贪吃蛇中的“吃食物”动作，一个游戏中贪吃蛇会吃到很多次食物，这也就是前面说到的“重复”。编程过程中，我们需要一直做这样的训练，发现程序中会一直持续的动作，然后将它打包起来，让计算机自己重复，以提高编写效率。学会利用这一点，我们就能学会整合讯息的能力。整合并不是简单相加，而是对现状的优化，也是推陈出新的方式之一。

其实编程也是一种语言的学习，只不过和人与人之间沟通不同的是，这种语言是人与计算机的沟通。理性、严谨是计算机的特性，所以与它对话的语言也必须是理性的，严谨的，不能出半点偏差的。"较真"，是外界对程序员们的评价，也是每一个程序员所遵守的信念。仍旧以贪吃蛇游戏程序为例，如果某处思考出现漏洞，游戏过程中就可能会出现“贪吃蛇撞了墙没死”或者“贪吃蛇吃到食物没有变大”等bug，那么这就是一个失败的程序。因此，学习编程，就是在对自己的逻辑思维和逻辑判断能力进行训练。

人的一生不可能不犯错。其实犯错也没什么，改了就好。而“改正”就是编程带给我们的逻辑能力中最重要的一项。但凡程序中出现与预期不一样的运行结果，都需要进行调试、修正。这个过程很麻烦，因为有些bug不是一下子就能找到的，常常需要从头梳理，十分考验人的耐心和细心程度。不过也正因此，才更能磨练出个人的品性，同时也能教会我们反思反省意识。

五、信息学竞赛对升学的帮助

2019年伊始，教育部发布了《关于做好2019年高校自主招生工作的通知》，提出了规范自主招生的“十严格”要求。文件中再次强调：降低自招优惠分值，降低自招优惠人数规模；论文、专利、机构的“假奖项”不得作为条件。导致的后果是文科类竞赛在自主招生中彻底出局，科创类竞赛含金量大幅缩水，学科竞赛类一家独大。

2019年《国务院办公厅关于新时代推进普通高中育人方式改革的指导意见》要求稳步推进高校招生改革。进一步健全分类考试、综合评价、多元录取的高校招生机制，逐步改变单纯以考试成绩评价录取学生的倾向。这就意味着综合评价政策在未来会成为多元录取的主要形式。但是从2019年采用综合评价的省市招生情况来看，学科竞赛依然是热门。

信息学竞赛是五大学科竞赛（数学、物理、化学、生物、信息学）之一，在信息学竞赛中获得奖励，对于当前自主招生和综合评价政策形式下的升学有很大帮助，至少是一块“敲门砖”。而信息学竞赛注重的更是思维的训练，编程只是解决问题的想法落地的工具！

中国计算机学会（CCF）于1984年创办全国青少年计算机程序设计竞赛（NOI），从此每年一次NOI活动，吸引越来越多的青少年投身其中。几十年来，通过竞赛活动培养和发现了大批计算机爱好者，选拔出了许多优秀的计算机后备人才。当年的许多选手已成为计算机硕士、博士，有的已经走上计算机科研岗位。

为了在更高层次上推动普及，培养更多的计算机技术优秀人才。竞赛及相关活动遵循开放性原则，任何有条件和兴趣的学校和个人，都可以在业余时间自愿参加。 NOI系列活动包括：全国青少年信息学奥林匹克竞赛和全国青少年信息学奥林匹克网上同步赛、全国青少年信息学奥林匹克联赛（NOIP）、冬令营、选拔赛和出国参加 IOI。

CSP-J/S：CCF非专业级软件能力认证(Certified Software Professional Junior/Senior，简称CSP-J/S)创办于2019年，是由CCF统一组织的评价计算机非专业人士算法和编程能力的活动。全国统一大纲、统一认证题目，任何人均可报名参加。CSP-J/S分两个级别进行，分别为CSP-J（入门级，Junior）和CSP-S（提高级，Senior），两个级别难度不同，均涉及算法和编程。CSP-J/S分第一轮和第二轮两个阶段。第一轮考察通用和实用的计算机科学知识，以笔试为主，部分省市以机试方式认证。第二轮为程序设计，须在计算机上调试完成。第一轮认证成绩优异者进入第二轮认证，第二轮认证结束后，CCF将根据CSP-J/S各组的认证成绩和给定的分数线，颁发认证证书。CSP-J/S成绩优异者，可参加NOI省级选拔，省级选拔成绩优异者可参加NOI。

NOIP：全国青少年信息学奥林匹克联赛(National Olympiad in Informatics in Provinces简称NOIP)自1995年至今。每年由中国计算机学会统一组织。 NOIP在 同一时间、不同地点以各省市为单位由特派员组织。全国统一大纲、统一试卷。初、高中或其他中等专业学校的学生可报名参加联赛。联赛分初赛和复赛 两个阶段。初赛考察通用和实用的计算机科学知识，以笔试为主。复赛为程序设计，须在计算机上调试完成。参加初赛者须达到一定分数线后才有资格参加复赛。联赛分普及组和提高组两个组别，难度不同，分别面向初中和高中阶段的学生。

六、编程并不难学

事实上，编程是一个简单的过程。编程的一个最重要的特点是，它提供了即时的反馈（编写代码运行就能马上看到效果），这是学习编程的关键。如果我们编写程序解决了一个问题，然后立即看到自己想要的结果，这样我们就已经知道自己正确地操作了程序代码。这种即时的正面强化是一种令人难以置信的强大工具。

学习如何编程就像学习其他语言一样，必须练习和测试技能。正如语言打开了人与人交流的能力，编程使我们有能力创造影响周围人的技术。只要有一台普通的电脑，我们就可以利用编程技巧来构建能够改变世界的东西。

如果你还没学习如何编程，现在是时候开始了！

七、几个程序（竞赛）网站

1. NOI官网：http://www.noi.cn/
2. 中国计算机学会：https://www.ccf.org.cn/
3. 块语言编程游戏：https://playground.17coding.net/
4. 洛谷：https://www.luogu.com.cn/

八、推荐学习书籍

信息学竞赛对于编程语言的大篇幅学习仅限于初期，后期主要内容是数据结构和算法。因此强烈不建议使用侧重编程语言系统全面学习的书籍（例如《C++从入门到精通》、《C++ Primer》），也不推荐不加甄别地通过网络教程学习（绝大多数网络教程同样偏重于编程语言的学习，并且有大量生僻对于竞赛不实用的内容）。这里推荐几本适合竞赛入门的学习书籍：

1. 《信息学竞赛一本通》（第五版 C++版）
2. 《深入浅出程序设计竞赛》（洛谷学术组）
3. 《CCF中学生计算机程序设计》入门篇、基础篇、提高篇
4. 《算法竞赛入门经典》与配套的《算法竞赛入门经典训练指导》

本文首先介绍程序与程序设计语言，这样我们对C++这一程序设计语言有一个初步的认识；最后介绍编写程序解决问题的一般方法和步骤。

一、程序与程序设计语言

计算机程序（Computer Program），是一组计算机能识别和执行的指令，运行于电子计算机上，满足人们某种需求的信息化工具。

计算机程序以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。

程序设计语言是用于书写计算机程序的语言。语言的基础是一组记号和一组规则。根据规则由记号构成的记号串就是语言。程序设计语言有3个方面的因素，即语法、语义和语用。

学习编程，至少需要掌握一门程序设计语言才能将自己解决问题的方法步骤（也就是算法）转化为实际的计算机程序来解决问题得出结果。既然称之为程序设计语言，作为一门语言就像英语一样有自己独特的语法，还好，一门成熟的程序设计语言实用的语法并不像英语那样复杂（要坚定学习的信心哦）。

自20世纪60年代以来，世界上公布的程序设计语言已经有上千种之多，但是只有很小的一部分的到了广泛的应用。

C++一直是一个热门的程序设计语言。C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++不仅拥有计算机高效运行的实用性特征，同时还致力于提高大规模程序的编程质量与程序设计语言的问题描述能力。目前信息学竞赛推荐使用的程序设计语言就是C++。

此外，竞赛编程和软件编程有一定的区别。竞赛编程学习初期会有大篇幅的程序设计语言的学习，后期主要内容就转向数据结构和算法了。程序设计语言只是一个能将我们解决问题的算法实现的工具，所以信息学竞赛的学习不要一味追求全面掌握某种编程语言的使用，只需要掌握对于竞赛实用的内容即可。

二、编写程序解决问题的步骤

这里简单介绍编写程序解决问题的步骤，在后续教程中还会结合实例对编程解决问题的方法和步骤展开更深入的分析讲解。

1. 分析问题。首先理清要处理什么样的数据，要得出什么样的结果；再进一步理清究竟要求解什么样的问题。就像我们做数学题一样，首先要认真读题、审题，明确题意。
2. 设计算法。在上一步理清了“究竟要求解什么样的问题”的基础上，进一步研究如何求解问题，找到解决问题的方法和步骤（第一步要干什么，第二步要干什么……）。就像我们做数学题一样，认真读题审题后，将问题与我们所掌握的知识进行关联，得出解决问题的方法和步骤。

举一个例子，“把大象放入冰箱”这一问题的步骤：第一步把冰箱门打开，第二步把大象放进去，第三步把冰箱门关上。像这样的解决问题的具体方法步骤，在程序设计领域称之为算法。只不过程序设计时算法的描述往往是可以用程序代码实现的，而不是像这里“把大象放入冰箱的三部曲”比较原始的自然语言描述。

在竞赛学习的过程中会接触到各种算法，并且我们会发现程序设计的精髓就是算法。

3. 编写程序。你没有看错，到了第3步我们才开始动手编写程序。一个良好习惯的程序员在动手编写程序前，会对问题经过思深熟虑的分析，进而得出解决问题的算法，然后才通过编写程序将算法转化成能够解决问题得出答案的程序代码。
4. 调试运行。最后，我们要调试运行写好的程序代码，查看运行结果是否和我们期望的结果一致。要解决的问题越复杂，往往程序也越复杂，这个时候调试运行也要做到全面不留死角，往往要经过科学合理的多次测试才能确保程序能够很好地解决问题。

如果程序调试运行时出现编译错误，我们需要去检查、找到并改正程序中的语法错误；如果运行结果与预期结果不一致，那么需要我们去分析修改程序中的逻辑错误；甚至运行结果与预期结果严重不符，那么可能是设计的算法有问题，这个时候还需要进一步去分析问题重新设计算法。

目前信息学竞赛推荐使用的程序设计语言是C++，C++编程的集成开发环境（IDE）很多，使用较为广泛的是Dev C++，在正式竞赛时提供给选手使用的计算机上也安装有Dev C++（目前NOI官方指定安装的Dev C++版本是5.9.2）。本图文教程将详细介绍安装Dev C++的过程。

1.点击上方的下载按钮，下载安装包，下载完成后双击安装包文件

2.等待安装程序自动解压加载完毕

3.弹出的对话框中，语言不作修改直接用 English（后续步骤会介绍在安装结束后将语言设置成中文），点击 OK

4.在对话框中点击 I Agree

5.在对话框中点击 Next

6.在对话框中，软件安装位置不作修改用默认即可，点击 Install

7.开始自动安装软件，等待自动安装结束

8.安装完毕后，在对话框中选择 Run Dev-C++ 5.9.2，点击 Finish

安装结束后，第一次运行Dev C++，会自动进入软件配置界面，设置软件的语言、主题等

9.在弹出来的配置对话框中，语言选择 简体中文/Chinese，点击 Next

如果第一次使用的过程中忘记了设置语言或者没有出现设置语言界面，可以参考文末的方法设置语言。

10.在配置对话框中直接用默认主题，点击 Next

11.点击 OK，至此 Dev C++安装并且设置完毕，会自动打开 Dev C++

12.桌面上自动产生了 Dev C++快捷方式， 以后直接双击快捷方式就能打开Dev C++

使用过程中修改界面语言的方法如下：

首先点击 "Tools" → "Environment Options..."：

然后在弹出的窗口中设置想要的界面语言即可：

本小节介绍Dev C++最基本的使用，包括打开Dev C++、新建源程序、编写程序、保存文件、编译程序、运行程序。大家注意快捷键的使用可以大大提高我们编程的效率。

回顾前面的内容，我们已经知道在Dev C++里编写程序解决问题前需要分析问题并设计算法。这两个步骤非常重要，切记不要看到问题就匆忙编写程序！下面介绍编程和调试运行环节Dev C++的基本使用。

1.打开Dev C++

安装Dev C++后在桌面上会自动创建Dev C++的快捷方式，在“开始”菜单里也能找到它的快捷方式，直接双击快捷方式就能启动Dev C++。

2.新建源程序（快捷键Ctrl+N）

通过“文件”→“新建”→“源代码”来新建源程序，也可以直接使用快捷键Ctrl+N。

3.编写程序

在代码编辑区编写程序代码，如果感觉编辑区字体太小，可以通过鼠标滚轮快速调节，具体做法是：在 Dev C++中按住 Ctrl 键不放，滑动鼠标滚轮可以调整字体大小（上滑鼠标滚轮放大，下滑鼠标滚轮缩小）。

这里给出C++程序的框架，也就是我们在编写程序前需要先输入的最基本的代码。我们不急着了解每句代码的意义和用途，先努力把这个最基本的程序框架记下来。

注意：虽然本网站教程中的代码均可以复制粘贴，但是在初学入门阶段强烈建议参照程序自行输入，不要复制粘贴，只有自己手写代码才能发现编码中的语法问题，通过不断出现问题、寻找发现问题、解决问题，在实际操作中积累经验，自己的编码能力才能得到快速充实的提升！

在Dev C++中编码的时候注意其自动补全的功能（例如输入左尖括号，自动补充右尖括号，并且光标位于两者中间），这明显提高了编码的效率。

#include<iostream>
using namespace std;
int main()
{
	
	return 0;
} 

还要关注Dev C++中代码自动“上色”的功能，代码的不同部分颜色可能不同。观察上面截图，第1行文字是绿色，using namespace int return这些单词被加粗显示（这些是C++的关键字）。通过这些特点可以方便我们查找编码中的错误（例如return拼写错误的话，这部分不会加粗）。

4.保存文件（快捷键Ctrl+S）

编写好程序后在编译运行前需要先保存文件（特别是第一次需要保存）。通过“文件”→“保存”来保存程序文件，也可以直接使用快捷键Ctrl+S。文件保存后我们会发现C++源程序的后缀名是.cpp。我们要养成良好的文件保存习惯，注意文件的保存位置和文件名的命名。

5.编译程序（快捷键F9）

C++源程序需要编译后才能运行。通过“运行”→“编译”来编译程序，也可以直接使用快捷键F9。

编译完成后在Dev C++下方的状态区域编译日志选项卡下会出现编译结果信息。如果提示0错误0警告，表示程序没有任何语法问题，编译成功。在Windows操作系统中编译成功后会在源程序所在的文件夹下生成与源程序同名的exe可执行程序。

如果提示有错误，那么编译失败。说明程序有语法问题，需要修改程序，直到编译无错误提示。

绝大多数情况下，编译出错后除了会给出错误提示信息，还会自动指出出错的位置。

通过上面编译出错情况的展示，我们应该能意识到编写程序是一件严谨的工作，关键处任何拼写错误或者遗漏必要符号都会导致编译错误！

对于初学者来说，出现编译错误不要怕，这些语法错误是最容易找出来并能较快修改过来的。我们要逐步培养并提升自己查找语法错误并快速改正的能力，最后熟练到不出现语法错误。这是一个需要大量上机操作实践并积累总结经验的过程！

6.运行程序（快捷键F10）

编译成功后，在Windows操作系统中编译成功后会在源程序所在的文件夹下生成与源程序同名的exe可执行程序文件。此时可以通过“运行”→“运行”来运行程序，也可以直接使用快捷键F10。其实这里是直接调用运行编译产生的exe可执行文件。

程序运行结果会通过自动打开的黑色控制台呈现。当前我们编写的是一个C++的框架程序，除了最基本的程序代码，没有其它任何语句（特别是输出语句），所以没有任何运行结果（需要注意的是，上图中红色方框内的信息是Dev C++平台给出的程序运行反馈信息，不是程序输出的内容！）。

我们修改之前的程序代码，在return 0;这一句前添加一句输出cout<<"Hello World";：

#include<iostream>
using namespace std;
int main()
{
	cout<<"Hello World";
	return 0;
} 

注意，修改代码后不能直接运行查看新程序的执行结果，而是需要先编译再运行。否则运行的仍然是上一次编译产生的exe文件，也就是修改前的程序代码。

为了避免我们修改代码后忘记了先编译程序而直接运行程序带来的困惑（修改了代码，却发现运行结果没有任何变化），我们可以使用“运行”菜单下的“编译运行”命令（或者使用快捷键F11），这个命令的作用是先编译再运行程序（如果出现编译错误会提示错误信息就不会再进入到运行环节）。

再试试输出其它内容吧！

#include<iostream>
using namespace std;
int main()
{
	cout<<"Hello World"<<endl;
	cout<<"世界你好"<<endl;
	cout<<"其它你想尝试的内容"<<endl;
	return 0;
} 

如果程序运行结果与预期结果不一致，那么需要我们去分析改正程序中的逻辑错误；甚至运行结果与预期结果严重不符，那么可能是设计的算法有问题，这个时候还需要进一步去分析问题重新设计算法。

再来试试下面这一段程序：

#include<iostream>
using namespace std;
int main()
{
	int n;
	cin>>n;
	cout<<n*n;
	return 0;
}

运行后会发现命令行窗口没有出现任何结果，只是光标一直在不停的闪烁：

这是因为这一段程序运行时需要使用者输入数据（本程序要求输入一个整数），我们尝试输入一个整数然后按下回车键，查看运行结果并猜想程序的功能。

注意：运行编译后的程序时，如果发现有下图中的错误提示“Failed to execute…”

出错原因是不小心将编译模式设置成了 64 位（使用的计算机却是 32 位操作系统），处理方法如下：（使用 TDM-GCC 4.8.1 32-bit Release）

此外，还有一种常见的错误，如下图所示：

错误提示信息指出，编译时无法生成可执行文件（没有权限）。出现这个问题的最可能原因是：之前编译运行过程序，且程序还未运行结束（一般是还在等待用户输入数据），这个时候由于操作系统限制不能删除正在使用的程序文件，所以编译无法生成新的可执行文件。此时只需要在任务栏找到并关闭之前的程序运行窗口，就能继续正常编译运行程序了。

7.调试程序

当程序运行发现结果与预期不一致时，我们可以通过Dev C++调试功能去排查程序中的逻辑错误，程序的调试方法会在后期教程中介绍。

为了尽快掌握基础知识，需要通过大量的练习测试。在练习的过程中，我们需要强有力的工具来获取大量的习题并且能够及时检测编写的程序是否正确（能够帮助我们测试编写的程序是否能很好地解决问题，不存在BUG），在线测评平台（OJ）能够满足我们的需求。

目前在线测评平台（OJ，Online Judge）很多，这里推荐几个实用的。

一、洛谷

洛谷创办于2013年，出道名为“洛谷Online Judge”，致力于为oiers/acmers提供清爽、快捷的编程体验。它不仅仅是一个在线测题系统，它拥有强大的社区、在线学习功能。同时，许多教程内容都是由五湖四海的oiers提供的，保证了内容的广泛性。无论是初学oi的蒟蒻，还是久经沙场的神犇，均可从洛谷获益，也可以帮助他人，共同进步。

1.注册账号

在洛谷首页右上角点击“注册”，进入注册页面。

可以选择电子邮件和手机号码两种注册账号方式。注意注册后需要按照提示激活账户。

2.登录洛谷

在洛谷首页右上角点击“登录”，进入登录页面。

输入用户名、密码和验证码，点击登录按钮登录。

3.题单刷题

点击洛谷网页左侧导航栏中的“题单”，进入到“题单广场”页面。洛谷的题单是按照学习进度来组织的，非常适合初学者。

4.题库刷题

除了上面介绍的题单刷题外，还可以使用题库刷题。点击洛谷网页左侧导航栏中的“题库”，进入到“题目列表”页面。注意：题库中的题不是按照学习进程来排序组织的，对于初学者来说，在题库中依次刷题很容易碰到暂时无法解决的难题。对于初学者，可以选择“入门与面试”类型题库进行练习。

5.提交程序

不管是题单、题库，点击题目名称，会打开题目具体描述页面。题目描述内容包括：题目背景、题目描述、输入格式、输出格式、输入输出样例和说明/提示。

首先要认真读题，明确输入输出（此时要特别关注题目中给出的输入格式和输出格式），明确要解决的问题并确定解决问题的算法，然后在本地（例如Dev C++或者后文介绍的洛谷在线IDE）中编写程序并调试运行，测试编写的程序是否能够解决问题（此时可以借助题目给出的输入输出样例来初步测试）。本地编程并调试运行测试无误后，再提交答案。

在代码提交页面选择程序语言为C++，将程序代码复制（使用右键菜单或者快捷键Ctrl+C）粘贴（使用右键菜单或者快捷键Ctrl+V）到代码输入区域中，然后点击提交评测（其实也可以提交源程序文件）。

然后会自动跳转到测评结果页面，等待程序测评结束（等待时间要看洛谷平台的负载情况），会给出详细的测评结果（包括是否通过，每个测评点的信息，源代码等）。

如果出现编译错误，在测评结果页面会显示编译错误信息。

6.加入团队

在洛谷中还可以加入学习团队（甚至可以自己组建团队），我们的学习团队里老师会发布作业、举行比赛，团队里也有题单和题目。下面介绍加入团队的方法：

1. 用个人账号登录洛谷：https://www.luogu.com.cn/auth/login
2. 登录后点击学习团队链接：https://www.luogu.com.cn/team/3639
3. 在团队页面点击加入团队按钮

4. 填写验证信息（真实的年级、班级、姓名，以方便团队管理员审核）

5. 等待审核通过（老师在QQ群里回复审核通过后自行刷新页面，或者等待一段时间刷新页面查看是否通过审核），审核通过后会出现如下提示：

6. 进入团队方法：鼠标移动到页面右上角个人头像上，在下浮菜单中点击我的团队。在我加入的团队里点击团队名称进入团队。

7.在线IDE

洛谷平台还提供了一个在线IDE，可以直接在网页中编辑程序并提交查看运行结果。如果我们安装Dev C++出现问题，可以直接在在线IDE中编程。并且洛谷的在线IDE提交的程序是在Linux环境下运行的，与信息学竞赛程序判分环境相同。

二、NOI OpenJudge

NOI OpenJudge最大的特色是所有题目按照学习进程组织，非常适合于初学者。

三、信息学奥赛一本通在线OJ

《信息学奥赛一本通》是一本影响较大，使用较为广泛的信息学奥赛入门教材（除一本通外，还推出了《训练指导教程》、《初赛篇》、《提高篇》、《高手训练》等系列丛书）。这套教材配套了在线OJ平台，包括基础知识、算法以及历届真题。

四、CCF中学生程序设计在线评测系统

“CCF中学生程序设计在线评测系统”是CCF（中国计算机学会，信息学奥赛官方组织）推出的OJ。

编写C++程序，首先需要书写一些固定的内容，这些内容称之为C++程序框架。本小节我们一起来学习C++程序框架，并编写第一个C++程序。

注意：虽然本网站教程中的代码均可以复制粘贴，但是在初学入门阶段强烈建议参照程序自行输入，不要复制粘贴，只有自己手写代码才能发现编码中的语法问题，通过不断出现问题、寻找发现问题、解决问题，在实际操作中积累经验，自己的编码能力才能得到快速充实的提升！

一、C++程序框架

编写C++程序，首先需要书写一些固定的内容，这些内容称之为C++程序框架：

#include<iostream>
using namespace std;
int main()
{
    
    return 0;
} 

现阶段我们还无法完全理解上面每句代码的意义和用途，先努力把这个最基本的程序框架记下来。这里给出一些简单的解释，阅读后能够初步了解语句代码的意义，也能够帮助我们记忆。首先特别强调的是：C++中和语法相关的字母符号都是英文。我们编码的时候往往是在英文半角状态下输入代码。

第一句 #include<iostream> 是引入头文件，使用#include语句引入了iostream这个头文件。程序往往离不开输入数据和输出结果，C++内置了用于输出信息和输入数据的函数（现在可以把函数理解成工具，就像烹饪时使用的锅和铲子一样），这些函数就在iostream这个头文件里，要使用输入输出函数（本文后面要介绍的cin和cout）就需要先引入iostream这个头文件。后面我们还会接触到其它头文件，甚至我们还可以自己组织头文件。

记忆技巧：include——包含，iostream是input output stream的简写，表示输入输出流。不要忘记include前面的#。

第二句 using namespace std; 表示使用std命名空间，命名空间是C++相对于C引入的新内容，暂时不用理解这一句的作用，只需知道使用这一句后可以直接使用cin、cout这些函数，而不需要写的过于复杂（std::cin，std::cout）。

记忆技巧：using——使用，namespace——命名空间（name+space），std是standard（标准）的简写。不要忘记语句末尾的英文分号 ; 。

接着 int main() 是主函数，可以看到后面有花括号{}，将主函数的内容包围了起来。计算机运行我们编写的程序时，会自动从int main后面{}中的第一句开始运行，依次运行每条语句，直到最后一句为止。

主函数最后一条语句 return 0; 意思是主函数返回一个0。其实是向操作系统表明程序正常运行结束。注意，在平时测评和竞赛时千万不要返回一个非0值。

记忆技巧：int——整数数据类型，main——主要的，return——返回。不要忘记main后面的小括号()，return 0;这一句以英文分号 ; 结束。

在Dev C++中编写程序框架代码，保存文件并编译运行，运行结果如下图所示：

程序运行结果会通过自动打开的黑色控制台呈现。当前我们编写的是一个C++的框架程序，除了最基本的程序代码，没有其它任何语句（特别是输出语句），所以没有任何运行结果（需要注意的是，上图中红色方框内的信息是Dev C++平台给出的程序运行反馈信息，不是程序输出的内容！，其实我们从反馈信息中可以得知程序运行耗时0.2095秒，返回值是0——这是代码return 0;这一句的作用）。

竞赛的编程关注的是数据的高效处理，所以从头到尾我们编写的程序都是这样的控制台运行效果，不会涉及到窗体编程。

二、Hello World 程序

很多程序设计教材的第一个程序都是“Hello World 程序”（输出文字Hello World ），C++的“Hello World 程序”如下：

#include<iostream>
using namespace std;
int main()
{
    cout<<"Hello World";
    return 0; 
} 

第一次正式地在Dev C++中书写程序，这里特别提出“编码规范”，目前需要注意做到合理缩进：

如上图所示，花括号{}中的内容没有顶在最左边写，而是缩进了一个制表符（键盘tab按键的效果就是一个制表符）。这样的好处是能够较好地展示出程序的结构，提高代码的可读性，特别是在程序结构复杂、代码量大的时候。幸运的是，在Dev C++中编码，会自动实现缩进功能（按下左花括号{并回车，会发现自动补齐了右花括号}，并且光标自动移动到了{}中的空行，光标所在位置也自动实现了缩进），如果没有自动缩进，可以通过tab键来实现标准的缩进。

对于初学者，养成良好的编码习惯其实很重要，能够确保代码可读性。初学者在编码时大家一定要注意编码规范，习惯成自然，开始时不注意后面就很难纠正。想想需要去阅读大量书写随意、格式乱糟糟的代码，肯定是一件痛苦的事情。你书写的代码或许就是老师或者同学痛苦的根源。

上面的示例程序，在主函数int main中，return 0;语句前添加了一句 cout<<"Hello World"; 一般情况下，代码都书写在return 0;前。cout用于输出信息，这里输出了一句话Hello World，这一句话要用英文双引号括起来。cout与输出的内容间用两个英文左尖括号（小于符号） << 隔开。

我们发现上面的程序中有三句代码：

using namespace std;
cout<<"Hello World";
return 0;

它们都是以英文分号结束的。C++中的语句普遍以英文分号结束（但不是所有）。

编译运行“Hello World 程序”，结果如下：

可以看到程序输出了一句话Hello World。我们可以尝试输出其它内容，甚至是中文内容（竞赛时几乎不会出现输出中文内容的情况），只需要修改英文双引号中间的内容即可。但是注意要输出的内容必须用英文双引号括起来，不能是中文引号（特别是在测试输出中文内容时，容易遗忘切换输入法导致输入了中文引号，此时编译会出现错误提示）。

三、初学者编码容易犯的语法错误

这里总结一下初学者容易犯的语法错误：

1. 框架中单词拼写错误。例如将main错误输入成mian；
2. 中英文符号错误。C++中和语法相关的字母符号都是英文。例如cout输出中文信息忘记切换输入法输入了中文的引号导致语法错误；
3. 遗忘语句结束符号——英文分号。C++中的语句普遍以英文分号结束，不要遗忘；
4. 遗忘main后面的小括号()和包围main函数内容的{}。

C++中一般使用cout来输出信息，输出的信息形式是多样的，可以是一句话（文本），也可以是数字（整数或者小数），甚至还可以是一个数学算式。

一、输出信息

回顾上一小节编写了第一个程序，使用cout输出Hello World：

#include<iostream>
using namespace std;
int main()
{
    cout<<"Hello World";
    return 0;
} 

我们再通过几段代码来进一步了解cout的使用方法，大家要多练习并仔细观察分析程序运行结果。通过上机实践来积累经验，逐步避免语法错误；通过观察结果分析代码功能，了解语句的作用：

#include<iostream>
using namespace std;
int main()
{
    cout<<"Hello World";
    cout<<"Nice to meet you!";
    return 0;
} 

Hello WorldNice to meet you!

再试试下面的代码：

#include<iostream>
using namespace std;
int main()
{
    cout<<"Hello World"<<endl;
    cout<<"Nice to meet you!";
    return 0;
} 

Hello World
Nice to meet you!

使用endl实现了换行效果。cout<<"Hello World"<<endl;这一句是cout输出语句，其实输出了两项内容——"Hello World"这句话和换行符（endl，可以将换行符理解成回车键效果）。可知cout可以一次性输出多项内容，每项内容间用两个英文左尖括号 << 隔开即可。

我们还可以尝试将输出语句修改成：

cout<<"Hello World"<<endl<<"Nice to meet you!";

二、程序注释

再来试试下面的程序，输出数字，甚至是计算式（表达式）。

注意下面的示例程序展示了如何在代码中添加注释，上机时下面程序中的注释信息不用书写，但要了解注释的使用方法和用途：

#include<iostream>
using namespace std;
int main()
{
    cout<<123<<endl;
    cout<<3.14159<<endl;
    //如果行内容以//开头，表示这一行的内容是注释（上机时这段程序时注释内容不用书写）
    //注释往往用来给阅读者一些提示信息或者是备注语句的作用
    //下面的注释就为大家解释了语句的作用，但是实际编程时只需要在必要的地方加上注释

    //输出两个数字（一个整数和一个小数），中间用一个空格隔开
    //cout输出了四项信息，整数123、只有一个空格的一句话、小数3.14159以及换行符
    cout<<123<<" "<<3.14159<<endl; 

    cout<<2*3.14159*12.56<<endl;       //输出半径为12.56的圆的周长（这里也是注释）
    cout<<3.14159*12.56*12.56<<endl;   //输出半径为12.56的圆的面积

    /*
    从上面的注释方法可以看出，一行中如果出现//，那么//之后的内容是注释
    //可能在行开始处出现，那么整行都是注释
    //也可能在行的语句后出现，那么//之后的内容是注释

    发现了吗？这里的内容也都是注释，并且是多行的（大家仔细查看多行注释开始结束的标记符号）
    //是行内注释，仅作用于一行内
    */
    return 0;
} 

注意 行内注释// 和 多行注释/**/的使用方法。良好的注释可以提高程序代码的可读性，也能避免遗忘重要语句的作用（有可能编写的代码过一段时间自己都读不懂，加上必要的注释能避免这样的情况）。

编译时编译器会自动去掉所有的注释信息然后生成exe文件，所以注释信息不会出现在最终的可执行文件中，很显然注释不会影响程序的运行效率。

三、输出信息小结

1. 使用cout语句输出信息，输出的信息可以是一句话（必须用英文引号括起来）、数字（整数、小数/浮点数）、变量（后续学习内容）、或者计算表达式：

cout<<"Hello World";
cout<<12345;
cout<<3.14159;
cout<<123*456;

2. 可以只输出一项信息，也可以一次性输出多项信息。cout与输出内容之间、各内容间均用 << 隔开：

cout<<1<<"+"<<2<<"="<<1+2;

3. 输出一个特殊的内容：endl 可以实现换行效果：

cout<<1<<"+"<<2<<"="<<1+2<<endl;

编写程序解决问题，往往离不开运算，从最简单的数学运算，到复杂的幂、开方、三角、对数，C++都能轻松应对。

一、基本数学运算

数学中最基本的是加(+)、减(-)、乘(×)、除(÷)四则运算，C++中有加(+)、减(-)、乘(*)、除(/)、模(%)五则基本运算。下面通过几个示例程序加以说明：

#include<iostream>
using namespace std;
int main()
{
    cout<<123+456<<endl;            //两个整数相加
    cout<<123.456+456.789<<endl;    //两个小数（浮点数）相加
    cout<<123-456<<endl;            //两个整数相减
    cout<<123.456-456.789<<endl;    //两个小数（浮点数）相减
    cout<<-789<<endl;               //-表示负数
    cout<<-(-789)<<endl;            //-也能表示取反
    return 0;
} 

编写并运行上面的程序，观察运行结果，可知用cout输出一个计算表达式，运行时会先计算结果，再将结果输出。再来看下面这段程序：

#include<iostream>
using namespace std;
int main()
{
    cout<<123*456<<endl;   //注意乘号是米字乘*，不能写成叉乘×，也不能写成点乘·
    cout<<123*-456<<endl;
    
    cout<<12.34*56.78<<endl;
    cout<<123.456*456.789<<endl;
    cout<<1234567.45*456.78<<endl;
    cout<<0.00123*0.004567<<endl;
    cout<<123.000<<endl;
    cout<<123.9999<<endl;
    return 0;
} 

在Dev C++中上面程序运行结果如下：

56088
-56088
700.665
56393.3
5.63926e+008
5.61741e-006
123
124

后面6行输出有点费解，和计算器算出来的结果不一致，原因是：cout输出小数（浮点数）时，默认最多保留6位有效数字（第3行输出700.665，第4行输出56393.3的原因）；如果数字太大或太小（绝对值超过$10^6$或者绝对值小于$0.00001$），会按照科学计算法的方式输出（所以第5行输出5.63926e+008、第6行输出5.61741e-006，5.63926e+008表示$5.63926 \times 10^8$，5.61741e-006表示$5.61741 \times 10^{-6}$）。cout输出浮点数会忽略掉小数末尾的0，所以第7行输出123，第8行保留6位有效数字并忽略掉小数末尾的0输出124。

也可以指定浮点数的输出格式，例如下面的程序指定浮点数保留5位小数输出（注意引入了一个新的头文件#include<iomanip>）：

#include<iostream> 
#include<iomanip>   //这个头文件不能少 
using namespace std;
int main()
{    
    //设置输出小数(浮点数)时保留5位小数
	//固定写法，保留其它小数位数修改setprecision()括号中的数字即可 
    cout<<fixed<<setprecision(5);
    //设置后，后面输出都会遵循输出规则 
    
    cout<<12.34*56.78<<endl;
    cout<<123.456*456.789<<endl;
    cout<<1234567.45*456.78<<endl;
    cout<<0.000009<<endl;
    cout<<123<<endl;      //输出123，setprecision设置的保留小数位数对整数无效
    return 0;
} 

程序输出结果如下：

700.66520
56393.34278
563925719.81100
0.00001
123

分析结果可知，保留小数位数的同时还自动实现了“四舍五入”！小结一下：引入iomanip头文件后，使用cout输出浮点数时可以通过cout<<fixed<<setprecision(要保留的小数位数);设置小数位数，保留小数位数时会自动实现“四舍五入”。其实这个保留小数位数的方法过于复杂，不好记忆，后面会介绍简单的方法。

再来看除法运算和模运算（模运算就是求余数）：

#include<iostream>  
using namespace std;
int main()
{    
    cout<<5/2<<endl;		// 整数/整数，注意除号必须用/
    cout<<4/2<<endl;		// 整数/整数 
    cout<<5.0/2<<endl;	  // 浮点数/整数
    cout<<5.0/2.0<<endl;	// 浮点数/浮点数
    cout<<5%2<<endl; 	   // %是模运算，这里计算5除以2的余数 
    return 0;
}

程序输出结果如下：

2
2
2.5
2.5
1

分析运算结果，会发现第1行 5/2 输出2与数学运算结果不一致。C++中的除法运算有一个特点，如果是 整数/整数 ，那么结果是一个整数（小数部分全部被舍弃，结果是除法的商），但是被除数或者除数只要有一个是浮点数，那么结果就是浮点数。

注意模运算仅限于 整数%整数 ，否则会出现编译错误！

小结一下：

1. 整数/整数 ，结果是除法的商；
2. 浮点数参与除法（被除数数和除数至少有一个是浮点数），结果是浮点数；
3. 整数%整数 结果是除法的余数。

最后，和数学混合运算一样，C++复杂的运算也涉及到运算优先级的问题：

#include<iostream>  
using namespace std;
int main()
{    
    cout<<1+2*3<<endl;
    cout<<(1+2)*3<<endl;
    return 0;
} 

大家自行编辑程序并运行，通过分析结果可知：C++中也是优先计算乘除（包括模运算），再计算加减；如果有小括号，那优先计算小括号中的内容。这和数学混合运算一致，有一点不同的是，不管多少层括号，都用小括号！

二、使用数学函数

来看一个数学问题，计算直角边为60和91的直角三角形斜边长。已知斜边计算公式 $c = \sqrt{a^2+b^2}$，这里平方和还容易得到：60*60+91*91，但是接下来的开平方是C++的五则基本运算无法实现的！

好在C++中已经内置了不少函数（目前可以把C++的函数理解成可以实现特定运算的工具），能够完成开平方、幂、三角、对数等数学计算。要解决上述问题，我们可以用到两个函数——pow幂函数和sqrt开平方函数，先编写一个程序来测试一下两个函数的功能（注意需要通过#include<cmath>引入cmath头文件）：

#include<iostream>
#include<cmath>  //需要引入cmath头文件  
using namespace std;
int main()
{    
    cout<<pow(60,2)<<endl;  //pow(60,2)计算60的2次方，然后cout输出结果
    cout<<sqrt(9)<<endl;    //sqrt(9)计算9开平方，然后cout输出结果
    return 0;
} 

计算斜边的公式 $\sqrt{60^2+91^2}$，对应的C++代码可以写成：sqrt( pow(60,2) + pow(91,2) )，这个复杂的计算表达式会首先计算sqrt()括号中的内容pow(60,2) + pow(91,2)，这是一个加法运算，那么会先后计算出pow(60,2)和pow(91,2)的值，然后相加的结果作为sqrt函数开平方的参数。最终程序代码如下：

#include<iostream>
#include<cmath>  //需要引入cmath头文件  
using namespace std;
int main()
{    
    cout<<sqrt(pow(60,2)+pow(91,2))<<endl;
    return 0;
}

其实pow函数可以计算小数次方，由数学知识可知 sqrt(9) 和 pow(9,0.5) 是等效的。那么还可以只使用pow函数解决问题：

#include<iostream>
#include<cmath>  //需要引入cmath头文件  
using namespace std;
int main()
{    
    cout<<pow(pow(60,2)+pow(91,2),0.5)<<endl;
    return 0;
}

这里将cmath头文件中常用的函数整理如下表：

建议自己编写程序测试一下上面cmath中的常用函数。

此外algorithm头文件下还有$max、min$两个常用函数：

三、浮点数的特点

程序设计语言中一般将小数称为浮点数（这个名称是根据浮点数在计算机内部存储方式得来的），来测试下面的程序：

#include<iostream>
#include<cmath>
using namespace std;
int main()
{
	cout<<ceil(1.01)<<endl;
	cout<<ceil(1.000000000000001)<<endl;
    cout<<ceil(1.0000000000000001);
    return 0;
}

2
2
1

感觉奇怪吧！注意：C++中的浮点数只能保证在一定的有效数字范围内是可靠的，超过这个范围就只能认为是约等于，不是精确相等！

cout<<1.0000000000000001;会输出1，后面的.0000000000000001超出了可靠的有效数字范围，C++处理时这部分被丢弃了！此时cout<<ceil(1.0000000000000001);其实就相当于 cout<<ceil(1);

前面学习的示例程序很简单，甚至会认为编写的程序无外乎就是一个“计算器”罢了。但是C++程序能完成的任务不仅仅计算几个表达式这么简单。有些复杂的问题需要经过多个表达式计算才能解决，这个时候需要想办法来存储计算的中间结果，使用变量能够很好应对这样的情况。

一、变量与赋值

小A在玩一个小游戏，玩游戏的过程如下：

1. 游戏开始时，有5条命
2. 第一关小A顺利闯过，没有损失命，获得2条命的奖励
3. 第二关小A顺利闯过，没有损失命，因为耗时比前一关长只获得1条命的奖励
4. 第三关小A顺利闯过，但太过大意导致损失了3条命，没有获得任何奖励
5. 第四关小A顺利闯过，损失了2条命，也获得了1条命的奖励
6. 最后一关较困难，小A损失了所有的命数也未能通关

现在编写程序输出游戏开始前和每关结束后小A的命数。你可能马上想到的是这样输出：

cout<<5<<endl<<7<<endl<<8<<endl<<5<<endl<<4<<endl<<0<<endl;

确实得出了正确的结果，但是这样编程没有体现出“让计算机来计算”，使用计算机就是要让计算机来计算解决问题的，这里却是人计算出了结果然后让计算机输出。借助变量可以这样编程：

#include<iostream>  
using namespace std;
int main()
{
    int n = 5;
    cout<<n<<endl;
    
    n = n+2;
    cout<<n<<endl;

    n += 1;
    cout<<n<<endl;
    
    n -= 3;
    cout<<n<<endl;
    
    n = n-2+1;
    cout<<n<<endl;

    n = 0;
    cout<<n<<endl;
    return 0;
} 

程序第5行 int n = 5; 定义了一个int类型的变量n，同时给变量n赋初值5。int是一种最基本的整数数据类型（后文会介绍），可以存储一个整数。这一句相当于给了一个专门存放整数的盒子，这个盒子的名称是n，最开始往里面存放了5这个整数。

第6行 cout<<n<<endl; 使用cout语句输出变量n的值，此时会输出5。这一句相当于取出了存放在名称为n的盒子的数拿来使用（输出这个数）。

第8行 n = n+2; 是一个赋值语句（第5行其实也是赋值语句，不过还先定义了变量n的数据类型为int）。注意这里的等号 $=$ 不能认为是判断相等（如果是判断相等，n=n+2是不成立的），这里的 $=$ 应该读作赋值成，$=$ 是赋值符号。这一句赋值语句就相当于向名称为n的盒子里放新的东西，首先会计算赋值符号右边表达式 n+2 的结果（要计算这个结果，首先要使用变量n的值，就和第6行输出n值一样，要取出名称为n的盒子里的数来参加计算，也就是取出来名称为n的盒子里的数+2），然后将计算结果（7）仍然存放到名称为n的盒子里，原来盒子里存放的数据会被丢弃。

这里小结一下，可以通过赋值语句为变量赋值，赋值语句的作用是先计算赋值符号右边表达式的结果，然后将结果赋值给左边的变量。给一个变量重新赋值，变量之前的值会被丢弃（标准说法是被覆盖掉）。在cout输出语句或者计算表达式中可以通过变量名取出变量当前存储的数据。

第11行 n += 1; 也是赋值语句，确切地说是“自赋值”。这一句的效果同 n = n+1; 一致，这里可以简单认为 n += 1; 就是 n = n+1; 的简写形式。作用是将n的值取出来，然后加上1，最后将结果又赋值给变量n。除了+=，还能使用 -= 、*=、/=、%=来进行自赋值。读者可以尝试修改第8行和11行原来的赋值语句为自赋值语句。

其实 n += 1; 还可以简写成 n++; 或者 ++n; （n++;和++n;两者在这里效果相同，但执行过程不同，后面会介绍）；同样的n -= 1; 可以简写成 n--; 或者 --n;

统观整个程序代码，会发现在程序运行过程中，变量n的值发生了多次改变（都是通过赋值语句实现的），这也是变量这一程序名词中“变”的含义。可以通过赋值语句（当然不仅仅是赋值语句）随时改变变量的值。

再来看一个计算圆的周长和面积的例子：

#include<iostream>  
using namespace std;
int main()
{
	double r;
	r = 12.56;
	cout<<2*3.14*r<<endl;
	cout<<3.14*r*r<<endl;
    return 0;
}

#include<iostream>  
using namespace std;
int main()
{
	double r,C,S;
	r = 12.56;
	C = 2*3.14*r;
	S = 3.14*r*r;
	cout<<C<<endl<<S<<endl;
    return 0;
}

对前面的内容做一个小结：

1. 变量在使用（为其赋值或者取出值参加计算）前必须先定义，定义变量的格式为：数据类型 变量名;
   可以在定义变量的同时为变量赋初值：数据类型 变量名 = 初始值;
   还可以一次性定义多个相同数据类型的变量：数据类型 变量名1,变量名2,变量名3,...;
   注意：变量名区分大小写！a和A是不同的变量。
2. 变量取名规范：
   1. 只能由大小写英文字母、数字、下划线（_）组成；
   2. 不能以数字打头；
   3. 不能使用C++的关键字。C++有不少关键字（又称为保留字），例如using、namespace、int、double、if、for、while等，使用关键字作为变量名会出现编译错误；
   4. 在同一作用域不能定义相同名称的变量，作用域的概念后续会接触到。例如：
      int n = 12;
int n = 0;
      会导致编译错误；
   5. 变量的取名不能太随意，建议做到“见命知义”，或者遵循一些普遍的做法（例如上面示例程序使用变量n来存储整数，后续还会接触到其它变量命名的普遍做法），这样不仅提高代码可读性方便他人阅读，也能使自己在编写程序时思路更加清晰。
3. 使用变量的值前，需要确保变量已经存储有确定的值。例如下面的语句：
   int n;
cout<<n<<endl;
   定义了变量n，但是没有为变量n赋值，后面直接取出变量n的值用于输出，这个时候变量的值是不确定的。在使用变量的时候要注意避免使用未赋值的变量的情况。
4. 赋值语句的格式为：变量名 = 计算表达式; 其中的 $=$ 是赋值符号，可以读作“赋值为”。赋值语句的作用是先计算赋值符号右边计算表达式的结果，然后将结果赋值给左边的变量。赋值后变量中存储的是新值，原来的旧值会被覆盖（丢弃）。
5. 自赋值语句的格式为：变量名 自赋值符号 计算表达式; 其中自赋值符号可以是 +=、-=、*=、/=和%=。自赋值语句的作用是先计算自赋值符号右边计算表达式的结果，然后将左边变量当前值与右边计算结果根据自赋值符号中的运算符进行计算，将最后结果赋值给左边的变量。例如 n += 1; 相当于 n = n+1; 。
6. n += 1; 还可以简写成 n++; 或者 ++n; ；同样的n -= 1; 可以简写成 n--; 或者 --n;。

二、数据类型

上面的讲解已经涉及到数据类型的概念。我们用“盒子存取东西”较为形象地说明变量的使用，那么数据类型可以理解成“盒子的类型”，不同的数据类型对应不同类型的“盒子”，就像现实生活中有用来装水、装油、装化学试剂的不同用途的盒子一样。要处理整数，那么应该用int类型的盒子，也就是要使用int类型的变量；要用变量存储圆的半径，为了提高程序的实用性，最好使用double类型的盒子（整数小数都能装下），也就是要使用double类型的变量。

在计算机内部，数据的处理采用的是二进制，二进制的最小单位是位bit（1个bit只能存放0或者1），最基本的存储单元是字节Byte（1个Byte是连续的8bit）。以存储整数的盒子（整数数据类型）为例，不同的数据类型还可以理解成“盒子的尺寸”，C++中就提供了1Byte、4Byte、8Byte这三个尺寸的盒子，分别对应char、int和long long三种存储整数的数据类型。不同的尺寸就意味着盒子的容量不同，对应地，不同数据类型的变量，能存储的数的范围不同。

以1个字节的char类型为例，其存储数据的方式和存储数据的范围如下图所示：

注意：计算机内部实际处理时，对于负数会采用“补码”的形式编码，char类型的负整数最小值是-128（$-2^7$）。

同样的分析可知，都可以用来存储整数的char、int、long long三种数据类型的存储范围：

• 1Byte（8bit）的char类型的存储范围是：$-2^{7}$ ～ $2^{7}-1$；
• 4Byte（32bit）的int类型的存储范围是：$-2^{31}$ ～ $2^{31}-1$；
• 8Byte（64bit）的long long类型的存储范围是：$-2^{63}$ ～ $2^{63}-1$

其实char、int、long long还有对应的无符号数据类型（只能存储非负整数）unsigned char、unsigned int、unsigned long long，也就是最高位不是符号位，所有的位都是数据位：

• 1Byte（8bit）的unsigned char类型的存储范围是：$0$ ～ $2^{8}-1$；
• 4Byte（32bit）的unsigned int类型的存储范围是：$0$ ～ $2^{32}-1$；
• 8Byte（64bit）的unsigned long long类型的存储范围是：$0$ ～ $2^{64}-1$

常见数据类型：

上表取值范围的“大约”表示保守估计，特别是float和double类型（char、unsigned char、int、unsigned int、long long、unsigned long long都有精确的取值范围，这几种数据类型表中给出的大约是为了给大家一个较为直观的感受）。这里也能看得出来，C++中对于浮点数，只能保证在一定的有效数字范围内是可靠的，不能保证浮点数是绝对精确的。

从表中可知存储整数的数据类型很多，但是long long的范围最大（只考虑有符号数），那是不是存储整数就都采用long long类型呢？答案是否定的。合适的才是最好的。编程时，对于要处理的数据大小范围是可以预估的，应该根据预估情况来选择合适的数据类型。计算机内存有限（竞赛时往往还会设定内存限制），如果都使用long long类型，那么在有限的总空间限制下，存储数据的数量就少了；并且一般来说，大范围的数据运算速度和小范围相比较还是有差异的。

一般情况下，使用int数据类型来存储整数，只有当int无法存储一些绝对值特别大的整数时，才使用long long数据类型；而浮点数一般都使用double，如果空间限制特别严格则使用float。至于long long都无法存储的超大整数，可以使用其它方法来模拟存储（算法部分的“高精度计算”会具体介绍）。

如果强行为变量赋值为超过其存储范围的数据，此时C++按照一定的规则处理，处理后实际存储到变量里的数据是不可靠的，这样的情况称为数据溢出，编程时要避免这样的情况。可以测试下面的程序：

#include<iostream>
using namespace std;
int main()
{
    int n = 2147483647;
    cout<<n<<endl;	//正常输出2147483647 
    n++;			  //n自加1，超出int存储范围，出现数据溢出（上溢） 
    cout<<n<<endl;	//输出-2147483648（不可靠） 
	
	int m = -2147483648;
	cout<<m<<endl;	//正常输出-2147483648
	m--;			  //n自减1，超出int存储范围，出现数据溢出（下溢）
	cout<<m<<endl;	//输出2147483647（不可靠）
    return 0;
} 

三、字符串类型string简介

除了上面介绍的常用的数值类的数据，程序中往往还要处理文本类型的数据，这些文本类型的数据更专业的称谓是“字符串”。C++中可以使用string类型来存储字符串，并且字符串还支持判断相等、加法（两个字符串拼接到一起）等运算：

#include<iostream>
using namespace std;
int main()
{
	string s1,s2;
	s1 = "Hello";
	cin>>s2;

	//这里的if语句后面会学习到
	if(s1=="Hello") cout<<"YES"<<endl;
	else cout<<"NO"<<endl;

	cout<<s1<<endl<<s2<<endl;

	cout<<s1+s2<<endl; 
	return 0;
}

后面会详细介绍字符串的使用。

四、常量的使用

回到前面计算圆的周长和面积的程序：

#include<iostream>  
using namespace std;
int main()
{
	double r,C,S;
	r = 12.56;
	C = 2*3.14*r;
	S = 3.14*r*r;
	cout<<C<<endl<<S<<endl;
    return 0;
}

程序中除了使用double类型的三个变量r,C,S外，还直接使用了一些数字：12.56、2、3.14159。像这样直接书写在程序中的量，称之为字面常量。

可以使用sizeof函数来计算常量或者变量所占存储空间的字节数，运行下面的测试程序：

#include<iostream>
using namespace std;
int main()
{
	cout<<sizeof(5)<<endl;	   //输出4，整数字面常量默认是int类型 
	cout<<sizeof(5LL)<<endl;	 //输出8，整数字面常量后加上LL，则是long long类型 
	cout<<sizeof(5.0)<<endl;	 //输出8，浮点数字面常量默认是double类型 
	cout<<sizeof(5.0F)<<endl;	//输出4，浮点数字面常量末尾加上F，则是float类型 
	return 0;
} 

再来看下面一段仍然是计算圆的周长和面积的程序：

#include<iostream>  
using namespace std;
int main()
{
	const double PI = 3.14;
	double r,C,S;
	r = 12.56;
	C = 2 * PI  * r;
	S = PI * r * r;
	cout<<C<<endl<<S<<endl;
    return 0;
}

第5行 const double PI = 3.14; ，是在普通的定义double变量PI并赋初值的语句 double PI = 3.14; 前面额外添加了一个修饰词 const。这样这个PI就成为了一个符号常量。这里的符号常量与变量用法一致，只是不能再修改它的值。一般约定符号常量名全部大写。

#include<iostream>  
using namespace std;
int main()
{
	const double PI = 3.14;
	PI = 3.14159;
    return 0;
}

#include<iostream>  
using namespace std;
int main()
{
	const double PI;
	PI = 3.14;
    return 0;
}

为什么要使用符号常量呢？假设我们要提高计算精度，需要将程序中的圆周率3.14修改成3.14159。使用字面常量修改如下（需要修改两处）：

#include<iostream>  
using namespace std;
int main()
{
    double r,C,S;
    r = 12.56;
    C = 2*3.14*r;
    S = 3.14*r*r;
    cout<<C<<endl<<S<<endl;
    return 0;
}

#include<iostream>  
using namespace std;
int main()
{
    double r,C,S;
    r = 12.56;
    C = 2*3.14159*r;
    S = 3.14159*r*r;
    cout<<C<<endl<<S<<endl;
    return 0;
}

如果不小心只修改了一处，那么程序就存在BUG（本例代码量少，排查时很容易发现BUG，如果代码量多，并且使用圆周率的语句也多，那就不好排查了。当然，遇到这样的情况是可以使用编辑器的替换功能来批量修改避免漏改导致的BUG）。

使用符号常量的修改如下（只需要修改一处，真正的“一改全改”）：

#include<iostream>  
using namespace std;
int main()
{
	const double PI = 3.14;
	double r,C,S;
	r = 12.56;
	C = 2 * PI  * r;
	S = PI * r * r;
	cout<<C<<endl<<S<<endl;
    return 0;
}

#include<iostream>  
using namespace std;
int main()
{
	const double PI = 3.14159;
	double r,C,S;
	r = 12.56;
	C = 2 * PI  * r;
	S = PI * r * r;
	cout<<C<<endl<<S<<endl;
    return 0;
}

此外，还可以通过C风格的#define语句来定义符号常量，注意语法与const的不同：

#include<iostream>  
using namespace std;
int main()
{
	#define PI 3.14
	double r,C,S;
    r = 12.56;
    C = 2 * PI  * r;
    S = PI * r * r;
    cout<<C<<endl<<S<<endl;
    return 0;
} 

#include<iostream>
#define PI 3.14  
using namespace std;
int main()
{
	double r,C,S;
    r = 12.56;
    C = 2 * PI  * r;
    S = PI * r * r;
    cout<<C<<endl<<S<<endl;
    return 0;
} 

#define其实是宏定义，编译时宏定义之后的代码中所有的 PI 会被简单粗暴地全部替换成3.14，所以这里不需要指定数据类型。

编写程序解决问题时，往往需要输入数据。计算的数据由使用者输入，可以大大增强程序的实用性。

一、输入数据

编写程序解决问题时，往往需要输入数据。例如前面示例程序计算圆的周长和面积，计算的是半径为12.56的圆，如果要计算其他半径的圆，需要修改源程序并再次编译运行，这样很不方便并且实用价值低。如果设计程序时，由使用者输入圆的半径，程序根据输入的半径计算圆的周长和面积，那么程序的实用性大大增强。

首先来看一个简单的，计算输入的整数的立方。这里通过cin语句将运行时输入的数据存储到变量中。

#include<iostream>
using namespace std;
int main()
{
    int n; 
    //使用cin语句输入一个整数存储到变量n中，cin和变量间用两个右尖括号(>>)隔开
    cin>>n;
    cout<<n*n*n; 
    return 0;
} 

运行后会发现命令行窗口没有出现任何结果，只是光标一直在不停的闪烁：

这个时候需要我们输入数据，本程序只需要输入一个整数，然后按下回车键，就能看到程序输出结果：

初学者还容易犯的一个错误就是将cin和cout后面的尖括号写错。cin后面是 >> ，cout后面是 << ，不要弄混了。可以这样来帮助记忆：

• cin是输入，将cin“想象成输入的数据”（其实就是输入流），两个右尖括号>>就像右箭头一样指示了左边输入的数据存储到右边变量中；
• cout是输出，将cout“想象输出到的位置”（其实就是输出流），两个左尖括号<<就像左箭头一样指示了是将右边的计算表达式结果输出到左边“要输出的位置”。

再来测试一个简单的程序，计算输入的两个整数的和：

#include<iostream>
using namespace std;
int main()
{
    int a,b; 
    cin>>a>>b;        //使用cin语句连续输入2个整数依次存储到变量a、b中
    cout<<a+b<<endl;
    cout<<a<<"+"<<b<<"="<<a+b;
    return 0;
} 

注意体会cin语句输入多个数据以及cout语句输出多项信息的使用方法。cin语句输入多个数据存储到多个变量，输入的多个数据按照cin语句中变量出现的顺序依次存储。

运行本程序，同样会发现光标一直在不停地闪烁，在等待输入数据。本程序需要输入两个整数，输入时可以先输入一个整数并回车，然后再输入另外一个整数并回车；也可以一次性输入两个整数，不过这两个整数间用空格隔开，最后回车。

再测试下面的程序，体会和上一段程序的不同：

#include<iostream>
using namespace std;
int main()
{
    int a,b,c;
    cin>>a>>b;      //使用cin语句连续输入2个整数存储到变量a、b中
    c = a+b;        //计算a+b的值，保存到变量c中
    cout<<c<<endl;
    cout<<a<<"+"<<b<<"="<<c;
    return 0;
} 

再来看一个经典问题：输入两个整数a和b，计算并输出 $a ÷ b$ 的结果：

#include<iostream>
using namespace std;
int main()
{
    int a,b;
    cin>>a>>b;
    cout<<a/b<<endl;
    return 0;
}

#include<iostream>
using namespace std;
int main()
{
    int a,b;
    cin>>a>>b;
    double c = a/b;
    cout<<c<<endl;
    return 0;
} 

#include<iostream>
using namespace std;
int main()
{
    int a,b;
    cin>>a>>b;
    cout<<1.0 * a / b<<endl;
    return 0;
}

#include<iostream>
using namespace std;
int main()
{
    int a,b;
    cin>>a>>b;
    cout<<a / b * 1.0<<endl;
    return 0;
}

#include<iostream>
using namespace std;
int main()
{
    double a,b;
    cin>>a>>b;
    cout<<a/b<<endl;
    return 0;
}

最后来看计算圆的周长和面积，圆的半径用cin输入：

#include<iostream>
using namespace std;
int main()
{
    const double PI = 3.14159;
    double r;      //为了增强程序的实用性，应该使用double类型来存储输入的半径
    cin>>r;
    cout<<2 * PI  * r<<endl;
    cout<<PI  * r * r<<endl;
    return 0;
} 

最后试一试下面的程序，并和前一段程序比较：

#include<iostream>
using namespace std;
int main()
{
    const double PI = 3.14159;
    double r,C,S;         //声明三个double类型（小数/浮点数）的变量r、C、S
    cin>>r;
    C = 2 * PI  * r;      //计算圆的周长并存储到变量C中
    S = PI  * r * r;      //计算圆的面积并存储到变量S中
    cout<<C<<endl<<S<<endl;
    return 0;
}