1.

一维数组：你的第一个“数据收纳盒”

刚开始学编程，你是不是觉得变量就像一个个小盒子，一个盒子只能放一个数字？比如int

=

5;，这个叫a的盒子里就稳稳地放着一个5。

这很好用，但如果你要处理全班50个同学的成绩，难道要定义50个不同的盒子吗？int

score1,

score50;光是写出来就够累的，更别说管理了。

这时候，你就需要认识编程里的“神器”——一维数组。

你可以把它想象成超市门口那一排整齐的寄存柜。

你定义了一个数组，就相当于申请了一整排带编号的柜子。

在GoC里，定义一排这样的“魔法盒子”超级简单。

它的格式长这样：

int
数组名[柜子数量];

举个例子，int

scores[50];这句话是什么意思呢？它告诉计算机：“嗨，给我来一排名字叫scores的柜子，不多不少，正好50个，每个柜子都用来放整数。

”

这样，你管理全班成绩的问题就瞬间解决了。

这里有个新手特别容易迷糊的关键点：柜子的编号是从0开始的，不是从1开始。

所以scores[50]这个数组，它的柜子编号是scores[0],scores[1],scores[2]...

一直到scores[49]。

没有scores[50]这个柜子，如果你去开它，程序就会“崩溃”，这是你第一个要记住的“坑”。

我刚开始用的时候，就老是把[50]里的“50”和最后一个下标49搞混。

我的经验是，你在心里把定义时的数字理解为“容量”，把使用时的下标理解为“序号”。

容量是50，序号最大就是49。

为了避免数组不够用，我们通常会稍微定义大一点，比如你知道最多有50个数据，那就定义int

scores[55];，多出来的5个作为“安全缓冲区”，这是个很实用的好习惯。

1.1

给数组“喂”数据：循环输入的艺术

定义好了空柜子，接下来就得把数据存进去。

你不可能写50行cin

>>

...吧？那太笨了。

这里就必须请出我们的老朋友——for循环。

循环和数组是天生的好搭档。

假设我们要读入10个同学的成绩，代码可以这样写：

int
a[15];
}

这段代码跑起来是什么感觉呢？想象一下：i就像一个自动移动的指针，第一轮循环i=0，cin就把第一个输入的数字放进a[0]柜子；第二轮i=1，数字放进a[1]...

直到10个数字全部各就各位。

这个过程就像流水线作业，高效又清晰。

我强烈建议你在初学阶段，亲手在纸上画一画这个流程：画一排小格子，标上0到9，然后模拟循环，把一组数字比如45,

32,

31...一个个“填”进去。

这个动作能帮你把“下标”和“元素”的关系刻在脑子里。

数组元素指的是柜子里存放的具体值，比如a[6]里放的93。

数组下标就是柜子的编号6。

我们通过下标来访问元素。

输出一个元素和输入一样简单：cout

<<

a[6];就能把93打印出来。

如果你想把这10个数字再全部输出一遍，同样用一个循环就搞定了：

for
(int
玩转数字：数位分离与组合的妙用
数组不只是个存储工具，它更是处理数据的好帮手。
一个经典的入门练习题就是“数位分离”。
比如给你一个整数1234，你怎么把它拆成1,2,3,4这四个单独的数字，并存入数组呢？
这里涉及一个核心技巧：利用取余（%）和整除（/）运算。
对于一个十进制数，%
10可以得到它的个位数，/
10可以去掉它的个位数。
我们用一个循环，就能像剥洋葱一样把数字的每一位剥下来。
情况一：已知固定位数。
比如题目保证是4位数。
int
num
个位：4
这种方法直截了当，但不够灵活。
情况二：位数不固定。
这才是更通用的实战方法。
我们不知道数字有多少位，那就一直剥到它变成0为止。
int
num
注意：这样存进去的顺序是倒着的！bits[0]=4,
bits[1]=3,
bits[3]=1
如果你希望数组里存的顺序和数字本身一致（bits[0]=1,
bits[1]=2...），可以在分离完后，将数组的前半部分和后半部分对称交换一下，这又是一个很好的循环练习。
有分离，自然就有组合。
把数组里的数字组合成一个整数，是反向操作。
例如把bits[0]=1,
bits[1]=2,
bits[3]=4组合成1234。
int
newNum
第四轮：123*10+4=1234
这个newNum
=
bits[i]的公式，请你务必理解并记住，它在处理数字类题目时出场率极高。
2.
走进图形世界：坐标系统的初体验
学编程如果只和黑底白字的数字打交道，久了难免枯燥。
GoC
一个迷人的地方就在于它能让你轻松地进入图形化世界，用代码来画画。
而要画画，首先得理解画布坐标系。
GoC
的绘图窗口，你可以把它想象成一张数学课上用的方格纸。
这张纸的中心点，就是坐标原点(0,
0)。
原点向右是X轴正方向，向上是Y轴正方向。
窗口的默认范围通常是X和Y都在-300到300之间（具体可能随版本调整）。
也就是说，最左边大概是(-300,
0)，最右边是(300,
300)，最下边是(0,
-300)。
这个坐标系和数学上的笛卡尔坐标系完全一致，非常直观。
在绘图前，我们得有一支“笔”。
GoC
里默认就有一支笔，我们通过命令来控制它移动和画画。
笔有两个最基本的状态：位置和方向。
初始时，笔一般停在原点(0,
0)，方向指向0度（正东方向）。
2.1
提笔移动：moveTo
的精准定位
当你想要笔不留下任何痕迹地移动到某个新位置时，就要用moveTo命令。
它的格式很简单：
pen.moveTo(x,
y);
y)处
你可以把它理解为“提笔，然后空降到指定地点”。
比如pen.moveTo(100,
50);执行后，笔就悄无声息地出现在了坐标(100,
50)这个点。
这个命令非常有用，常用于确定绘图的起始点，或者在不该画线的地方跳跃过去。
我刚开始画复杂图形时，常常因为笔的当前位置没搞对，画出来的线乱成一团。
后来我养成了一个习惯：在开始画一个新部分之前，先用pen.moveTo()把笔明确地放到我想要的起点上，这样思路就清晰多了。
2.2
落笔画线：lineTo
的轨迹绘制
真正让笔留下痕迹的是lineTo命令。
它的格式和moveTo很像：
pen.lineTo(x,
y);
y)
关键区别在于：lineTo会画出一条线。
比如，笔当前在(0,
0)，执行pen.lineTo(100,
0);后，你会看到一条从原点向右延伸100个单位的水平线段。
而且，画完之后，笔的位置就停留在了(100,
0)这个终点上，但笔的指向方向不会改变（这一点和后面会学到的forward命令不同，forward移动后会改变笔的朝向）。
lineTo是最直接的“两点连线”命令。
如果你想画一个三角形，代码可以这样写：
pen.moveTo(0,
0);
(这里86约等于100*sqrt(3)/2，是个等边三角形)
pen.lineTo(0,
画边回到起点A，闭合三角形
通过组合moveTo和lineTo，你已经可以画出任何由直线段构成的图形了。
这里有个小技巧：计算好每个顶点的坐标是成功的关键。
对于规则图形，可以尝试先在草稿纸上列出各点坐标，再翻译成代码。
3.
数组与坐标的第一次握手：用数据驱动绘图
前面我们学了数组存数据，也学了坐标来画画。
那它们俩怎么能结合起来呢？这才是最有趣、也最能体现编程力量的地方。
我们可以把图形的关键坐标点存放在数组里，然后用循环来读取这些坐标并绘制。
这样一来，修改图形就变成了修改数组里的数据，而不是重写一大堆绘图命令。
让我们来看一个最直接的例子：绘制一条折线，连接若干个给定的点。
假设我们有5个点的坐标，我们可以用两个数组来分别存储它们的X坐标和Y坐标。
//
int
}
这段代码执行的效果，就是笔依次连接(-200,0)
->
(200,0)这五个点，画出一条“波浪形”的折线。
试想一下，如果没有数组，你要写5次lineTo，如果点有100个呢？而用了数组，无论多少个点，for循环的代码框架都不用变，只需要改变数组里的数据和循环次数n就行了。
这种“数据与逻辑分离”的思想，是编程进阶的重要一步。
3.1
实战案例：绘制函数图像
结合数位分离和坐标绘图，我们能做更酷的事情——绘制简单的函数图像。
比如，我们想画出抛物线y
=
100在X从-200到200之间的一段。
思路是：我们用一个循环，让X值一步步变化，计算出对应的Y值，然后让笔移动到或画线到这个(x,
y)点。
为了画出连续的曲线，我们用很多个很短的直线段来近似。
pen.moveTo(-200,
(-200)*(-200)/100);
}
这个例子中，x本身是循环变量，同时它又是计算y的依据，最终共同构成了绘图坐标。
你会发现，编程让数学公式“活”了过来，变成了屏幕上可视的图形。
你可以尝试修改公式，比如把x*x/100改成100*sin(x/10.0)（注意引入数学库并处理浮点数），立刻就能看到正弦波的图案。
这种即时反馈的成就感，是学习编程的巨大动力。
4.
避坑指南与高效技巧
踩过不少坑之后，我总结了一些新手在结合数组和坐标绘图时最容易遇到的问题和提升效率的技巧。
第一大坑：数组下标越界。
这是最常导致程序崩溃的原因。
记住，如果你定义了int
a[10]，你能合法使用的下标是a[0]到a[9]。
在循环时，务必检查循环条件，确保i的值在这个范围内。
一个经典的错误是：
for
(int
当i=10时，a[10]越界！
第二大坑：坐标超出画布范围。
GoC的画布大小是有限的。
如果你计算出的坐标值远远超过±300，比如pen.lineTo(1000,
1000)，那么画出的线你可能看不到（因为跑到窗口外面去了），或者导致绘图异常。
在计算坐标时，心里要对数值范围有个大概估计，可以通过缩放系数来调整。
比如你想画的函数值很大，可以统一除以一个倍数，把它“压缩”到画布能显示的范围内。
第三大坑：忘记笔的当前状态。
笔的位置和方向是连续的。
上一条命令结束的位置，就是下一条命令开始的位置。
很多图形画错了，就是因为没理清笔的移动轨迹。
我的建议是，在画复杂图形时，多用pen.moveTo()来明确指定起点，而不是依赖笔的“历史位置”。
同时，可以善用pen.up()（提笔）和pen.down()（落笔）命令来精确控制什么时候该画线，什么时候只是移动。
高效技巧一：使用常量定义画布参数。
如果你经常调整图形大小，可以把画布的尺寸、缩放比例等定义为常量。
const
int
SCALE;
这样，想整体调整图形大小时，只需修改SCALE这一个常量，所有坐标都会自动变化，比一个个去改数字要安全高效得多。
高效技巧二：封装重复的绘图动作为函数。
如果你发现某段绘图代码（比如画一个正方形、画一个圆点）要使用很多次，就应该把它写成一个函数。
//
void
在(150,150)处画一个边长50的正方形
这样做不仅让主程序更简洁，而且极大提高了代码的复用性和可读性。
当你从“写一行行命令”进化到“调用一个个功能模块”时，你的编程思维就上了一个新台阶。
学习GoC的数组和坐标绘图，就像获得了两种基础但强大的工具。
数组让你能规整地处理数据，坐标绘图让你能直观地展现逻辑。
把它们结合起来，你就能用程序表达想法，从枯燥的数字计算跃迁到生动的图形创造。
多动手试，从画简单的线段、方块开始，逐步挑战更复杂的图案，过程中遇到的每一个错误，都是你理解更深入的契机。