C语言栈实现数制转换：原理、实例与边界处理

简介：C语言顺序栈实现的数制转换实例，面向正在学习数据结构与算法的初学者，帮助理解栈的后进先出特性与十进制转八进制、任意进制的核心流程。压缩包内仅含1个PDF文档，大小47KB，集中讲解SqStack结构定义、初始化、压栈、出栈、判空等关键函数，并给出可直接调试运行的完整实例代码，代码变量与函数命名规范，注释清晰，便于逐段阅读和实验。已有894人浏览学习，难度适中，适合课堂同步练习或自学巩固。文档针对严蔚敏数据结构教材中的伪代码做了详尽展开，弥补了初学者不易理解与实现的痛点；读者不仅能掌握数制转换的算法原理，还能通过代码提升对栈的应用能力，并方便迁移到其他进制转换场景，也可作为课程设计或实验报告的参考。

1. 数制转换为什么是数据结构课的第一道必做题

某次面试，面试官让我用 C 语言实现十进制转二进制，我几乎是条件反射地写出「除 2 取余、倒序输出」的循环。写完后他问了一句：如果限定只能用数据结构里的栈写，你会怎么改？那一刻我才意识到，自己之前只是背熟了算法，并没有真正理解为什么要把余数压进栈再弹出来。

这道题就是 C 语言数据结构中数制转换实例代码在课本、课程设计和机试里反复出现的原因。它表面考进制算法，实际考的是「能不能把逆序输出这件事抽象成后进先出」。短除法产出的余数顺序天然相反，栈恰好是保存并反转这个顺序的容器，因此它往往被当作栈章节的第一个完整实例，也是理解栈这个抽象类型的入门台阶。

适合读这篇笔记的人很明确：正在学数据结构的学生，准备笔试机试的求职者，以及想补算法基础的开发者。你不需要已经熟练掌握栈，只要会基本的 C 语言语法就够。下面会先从原理讲清楚栈为什么合适，再给出一份能直接编译运行的实例代码，最后把最常见的几个翻车点挨个排查一遍。

2. 从短除法到后进先出：栈为什么天生适合数制转换

2.1 短除法产生的余数，顺序本来就是反的

十进制转二进制用的是短除法：不断除以 2，取每次的余数，从最后一次除法得到的商为 0 时结束。拿 13 举例，完整的除法过程是这样：

13 / 2 = 6 余 1 6 / 2 = 3 余 0 3 / 2 = 1 余 1 1 / 2 = 0 余 1

如果从上往下读余数，得到的是 1、0、1、1，写成整数是 1011，这显然不对。正确的二进制结果是 1101，也就是要从下往上读。换句话说，先算出来的余数要放到最后输出，后算出来的余数要先输出。

这就是数制转换最反直觉的地方：算法本身只需要几行除法，真正的难点全在最后一步的逆序。新手最常写的错法是循环里直接printf("%d", n % base)，然后得到一串反的 1011，还一脸困惑地怀疑除法写错了。其实除法完全正确，缺的是一个能临时存住余数、再按相反顺序取出的容器。

数组也能做到这件事：先按顺序存到数组，再用一个倒序循环输出。但数组方案需要记录当前存到了第几位，还要单独再写一个从尾部往前走的循环，代码并不比栈短，而且把「逆序」这个意图淹没在了下标计算里。栈的好处是语义直接：余数压进去，再依次弹出，弹出的顺序天然就是反的，不需要任何额外计算。

2.2 顺序栈还是链栈：考场用顺序，工程用链式

栈的实现方式不止一种，常见的是顺序栈和链栈。顺序栈用一段连续数组加一个栈顶指针实现，入栈就是先移动指针再写值，出栈就是读值再回退指针，整个实现不到 20 行。链栈则是每个节点单独申请内存，通过指针串起来，理论上只受内存总量限制。

做题、考试、机试，我一般首选顺序栈。理由很简单：代码短，逻辑直白，调试时数组内容一目了然，而且多数题目会明确给数值范围，比如 int 范围内的十进制数，二进制最长不过 32 位，一个 64 长度的数组已经绰绰有余。链栈在作业里反而不是好选择，因为你要额外写节点释放，稍有遗漏就内存泄漏，面试官看到还会追问两句。

什么时候该用链栈？数据量完全无法预计，或者数值可能非常大，比如转换成二进制后位数超过几千位。这时固定数组要么浪费空间，要么不够用。另外，如果你在封装一个对外使用的库函数，不清楚调用方会塞进来多大的数，用动态扩容或链栈更稳妥。判断标准就一句话：栈的容量是不是已知且有限，是则顺序栈，否则考虑链栈或动态数组。

2.3 先搭好能独立编译的栈操作函数

后面的转换代码全部基于这一组栈操作函数，所以先把它们写完整、跑通，再继续往下走。这里采用顺序栈，容量 64，足够覆盖 64 位整数转成二进制的全部位数。

#include <stdio.h> #include <stdlib.h> #define MAX_SIZE 64 /* 栈容量：64位整数二进制最长64位，64足够 */ typedef struct { int data[MAX_SIZE]; int top; /* top 指向栈顶元素，空栈时为 -1 */ } Stack; void initStack(Stack *s) { s->top = -1; } int push(Stack *s, int value) { /* 栈满返回 0，调用方可根据返回值决定是否停止入栈 */ if (s->top >= MAX_SIZE - 1) { return 0; } s->data[++(s->top)] = value; return 1; } int pop(Stack *s, int *value) { /* 栈空返回 0，value 通过指针带出栈顶元素 */ if (s->top == -1) { return 0; } *value = s->data[(s->top)--]; return 1; } int isEmpty(Stack *s) { return s->top == -1; }

这里的几个细节要解释清楚。top初始化为 -1，代表空栈；入栈时先自增再赋值，所以栈顶始终指向最后一个有效元素；出栈时先取值再自减，弹出去的元素位置不再参与后续读取。push和pop都带返回值，是为了让调用方能感知栈满和栈空，这个设计在后面排查问题时会发挥关键作用。

初始化、入栈、出栈、判空四个函数分开写，看起来比直接塞进main里多几行，但换来的是后面每个实例代码都能复用同一套逻辑。测试时可以单独写一个main，入栈 1、2、3，再连续弹出三次，看是否依次得到 3、2、1，确认无误后再进入下一步。

3. 在本地跑通第一个转换器：完整实例代码与逐段说明

3.1 主函数写得越直白越容易调

有了栈操作函数之后，转换主函数就很短了。下面这份代码完成十进制到二进制、八进制、十六进制的转换，输出存进字符串，方便后续处理。

void convert(int n, int base, char output[], int *len) { Stack s; initStack(&s); /* 下标即余数：余数 0~15 分别对应字符 0~9、A~F */ static const char digits[] = "0123456789ABCDEF"; /* do-while 保证 n=0 时也会至少入栈一个数字 0 */ do { push(&s, n % base); n /= base; } while (n > 0); int idx = 0; int val; /* 依次弹出，弹出的顺序正好是从高位到低位 */ while (pop(&s, &val)) { output[idx++] = digits[val]; } output[idx] = '\0'; /* 手动补字符串结束符 */ *len = idx; } int main(void) { int n = 255; char bin[64], oct[64], hex[64]; int len; convert(n, 2, bin, &len); printf("%d 的二进制: %s\n", n, bin); convert(n, 8, oct, &len); printf("%d 的八进制: %s\n", n, oct); convert(n, 16, hex, &len); printf("%d 的十六进制: %s\n", n, hex); return 0; }

编译运行后，输出依次是11111111、377、FF，对应的十进制数都是 255。这段代码的核心逻辑集中在convert函数里：先不断取余入栈，再不断出栈写入字符串。为什么选择把结果写入output而不是直接printf？因为转换结果往往要被后续逻辑使用，比如拼接到日志、传给下一个函数，直接打印就把结果锁死在了终端里。

digits数组用static const修饰，是因为它不需要被修改，也不需要每次调用都重新初始化，编译器会把它放到只读数据段。数组下标恰好对应余数的值，余数 10 就取到字符A，余数 15 取到F，这个查表技巧后面会单独讲。

3.2 用 do-while 解决最容易漏掉的 0

while (n > 0)是最容易写出的循环写法，但它有一个致命问题：当输入的十进制数是 0 时，循环体一次都不会执行，栈里什么都没有，输出结果是空字符串。很多人在作业里第一次跑 0 的用例，看到终端什么都没打印，第一反应是编译器坏了，其实是循环条件把 0 挡在了门外。

解决办法有两个。第一个是用if (n == 0)提前把数字 0 压入栈，然后再走常规循环；第二个是改用do-while，让它无条件先执行一次。我推荐第二种写法，它少一个分支，逻辑更紧凑。第一次执行时取0 % base，结果是 0，入栈，然后n变成 0，循环条件不成立，退出，最后弹出数字 0。整个过程恰好一次入栈一次出栈，干净利落。

不过do-while也有需要注意的地方：如果调用方传入的n本身就是负数，n % base会得到负余数，入栈后再弹出来就无法映射到digits的正确字符。这个坑在负数场景专门讨论，这里只要记住：do-while解决的是 0 的问题，不解决负数的问题。

3.3 从 2 进制到 16 进制：只有查表这一种可靠写法

余数的取值范围从 0 到base - 1，当 base 是 16 时，余数最大到 15。新手很容易写出两种错误：第一种是printf("%d", n % base)，余数 10 会输出两个字符1和0，整个十六进制结果就错位了；第二种是printf("%c", '0' + n % base)，这个写法只对 0 到 9 有效，余数 10 时'0' + 10计算出来是:字符，根本不是字母。

正确做法是准备一张字符表，让下标直接对应余数。"0123456789ABCDEF"这个字符串里，digits[0]是'0'，digits[10]是'A'，不需要任何 if-else 判断。这也是我在转换函数里坚持用static const char digits[]的原因。

查表法的另一个好处是扩展进制方便。如果之后想支持 base 16 以上的进制，只需要把表加长，比如三十二进制用"0123456789ABCDEFGHIJKLMNOPQRSTUV"，转换逻辑一行都不用改。相比之下，用 if-else 判断余数 10 到 15 的做法，每换一个进制就要改一遍分支，维护成本很高。

3.4 先跑冒烟用例再交作业：3 个必须过的输入

代码写完不要直接交，先跑一组冒烟用例。所谓冒烟，就是挑最小、最大、最典型的值各试一轮，确认基本流程没断。数制转换至少要过下面三个输入：

表格：

这三个用例都过了，基本逻辑就没问题。如果在 255 转十六进制时输出变成1FF或1 15 15，那就是上一节说的查表没做对，直接回头改digits相关代码。冒烟用例跑完再补负数、大数、非法进制的测试，这是我一贯的顺序。

4. 参数与边界：把转换器改造成能处理负数、非法输入和大数的健壮版本

4.1 目标进制这个参数：如何校验

convert的第二个参数是目标进制，但这个参数不能被无条件信任。调用方可能传入 1、0、17 甚至负数，这些值要么没有数学意义，要么超出查表范围。当 base 为 1 时，短除法永远取不到 0 的商，循环会变成死循环；当 base 大于 16 时，digits表越界，读到的字符是乱码。

所以函数入口处要加参数校验：

if (base < 2 || base > 16) { return -1; /* 非法参数统一返回 -1 */ }

返回 -1 是 C 语言里常见的错误约定，调用方通过返回值判断这次的转换是否成功。有些初学者喜欢在函数里用printf打印一句「参数错误」，但库函数最好保持安静，把错误判断权交给调用方。如果封装成 API，对外暴露的接口应当一目了然：传入合法参数返回结果长度，非法参数返回 -1。

表格：

输出缓冲区同样要校验。如果调用方传进来的是 NULL，函数里直接写out[0]会触发段错误，这是移植到不同平台后最常见的崩溃来源。

4.2 负数的三种处理策略

负数转换是个容易含糊的问题，因为 C 语言对负数取模的规则在不同年代的标准里不一致。C99 之前是实现定义，C99 之后规定商向零取整，余数的符号与被除数相同。也就是说，-15 % 2在常见编译器下结果是 -1，直接把负余数塞进栈，后面取到digits[-1]就是越界。

常见的处理策略有三种。第一种是带符号输出：检测到负数后，先往结果字符串里写一个-，再把绝对值送去转换，适合一般的作业和机试题。第二种是只转换绝对值，符号交给调用方管理，适合封装库。第三种是补码表示，直接对内存里的位模式做运算，适合计算机组成原理方向的课设。大多数场景用第一种就足够。

int toBase(long long n, int base, char out[], int outSize) { if (base < 2 || base > 16 || outSize <= 0) { return -1; /* 参数非法 */ } int neg = 0; if (n < 0) { neg = 1; n = -n; /* 取绝对值，配合 long long 避免溢出 */ } Stack s; initStack(&s); static const char digits[] = "0123456789ABCDEF"; do { push(&s, (int)(n % base)); n /= base; } while (n > 0); int idx = 0; if (neg && idx < outSize - 1) { out[idx++] = '-'; /* 负号先入串，再写数字 */ } int val; while (pop(&s, &val) && idx < outSize - 1) { out[idx++] = digits[val]; } out[idx] = '\0'; return idx; }

参数说明：n使用long long类型，是因为int最大约 21 亿，转成二进制需要 32 位，本身够用；但取绝对值时如果输入是最小负数，-n会溢出回绕，用long long就留出了余量。outSize是缓冲区长度，每次写入前都检查idx < outSize - 1，给结尾的'\0'留位置。

4.3 栈容量不够会发生什么：溢出保护

固定容量的顺序栈最怕栈满。转换一个long long类型的最大值到二进制，需要 64 位，MAX_SIZE定义成 64 恰好够；但如果之后把输入类型改成更大整数，或转换成更小进制的字符串，位数会超过容量，push返回 0，而转换函数里没有检查返回值，后续pop就会读到未初始化或残留的数据，结果开头多出几个随机数字。

这种错误是典型的「玄学 bug」：本地跑小数字一切正常，一测大数就乱。避免的方式有两种。一种是在push后立刻检查返回值，失败就返回错误码退出；另一种更稳妥的做法是转换前先数一遍循环次数：

int count = 0; long long temp = n; while (temp) { temp /= base; count++; } /* 加上负号位和结束符，count 必须小于 outSize */ if (count + (n < 0 ? 1 : 0) + 1 > outSize) { return -1; }

数完位数再决定要不要执行转换，相当于给栈上了一份保险。这个检查在栈容量固定的场景下几乎是必写的，因为调用方无法预知你会不会传入一个超出预期的值。血泪经验是：不能假设调用方和你一样清楚栈的容量边界。

4.4 把输出结果抽象成字符串：给后续复用留接口

到了这一步，convert函数已经从「打印结果」演进成了「生成字符串」。这两者的差距不是几行代码的事，而是接口设计思路的转变。void convert(int n, int base, char output[], int *len)这个签名里，output是调用方提供的缓冲区，len是函数回传的结果长度，调用方拿到字符串后想打印、想拼接、想过网络发送都行。

如果之后要做进制转换的换算器，把十六进制结果再拆成字节数组，这个字符串接口就能直接对接。如果哪天需要把转换逻辑嵌入到更复杂的解析程序里，只需要把栈操作换成更快的位运算，对外接口完全不用变。这也是为什么我坚持不在函数里直接printf，宁可多写一个output参数。

接口风格上，我习惯让函数返回int：0 表示成功，-1 表示参数错误，正数表示结果长度。C 语言没有异常机制，用返回值表达错误是约定俗成的做法。调用方拿到 -1 后自行决定是打印错误还是用默认值兜底，责任清晰。

5. 数制转换常见问题排查：现象、原因、解决

5.1 输入 0 时输出空白

现象：输入数字 0，程序跑完终端什么都没打印，或者只打印了一个换行。原因：转换函数用的是while (n > 0)，n 等于 0 时循环条件立刻失败，栈里一个元素都没有，最后出栈循环也没执行，输出字符串只有结尾的'\0'。解决：改用do-while，或者进入函数后先用if (n == 0)单独把数字 0 压栈。两种办法都能过这个用例，do-while代码更少，推荐前者。

5.2 十六进制输出变成乱码或两位数

现象：255 转十六进制，预期FF，实际输出1 15 15或1::，有时还夹杂不可见字符。原因：直接把余数当整数打印，或者用'0' + rem计算字符，余数 10 到 15 没有对应的字母映射。解决：用"0123456789ABCDEF"查表，output[idx++] = digits[val]，让下标和余数一一对应。这个坑出现频率极高，几乎每个班都会有人踩，排查时第一眼先看输出里有没有大于F的字符或奇怪符号。

5.3 负数转换后符号丢失或结果异常

现象：输入 -15，输出1111或者-1之类不符合预期的结果。原因：负数取模在不同标准下行为不同，C99 之后余数与被除数同号，-15 % 2是 -1，入栈后查表越界；同时while (n > 0)对负数直接跳过，整个转换流程从第一步就错了。解决：函数入口处先判断符号，负数置标记位，取绝对值后再走转换，最后在字符串头部写负号。注意n = -n这一步要用long long类型承载，否则最小负数取绝对值会溢出。

5.4 输出开头多出随机字符

现象：大数转换的结果前面多出几个数字或乱码，小数字时一切正常。原因：MAX_SIZE不够，push在栈满后返回 0，但转换函数没检查返回值，继续往上写越界位置；之后pop又把越界写过的残留值弹了出来。解决：转换前数一遍结果位数，加上负号和结束符后检查是否超过缓冲区；或者在每次push后判断返回值，失败立即返回错误码。这个问题在把输入类型从int扩到long long时最容易冒出来，改类型的同时要同步检查栈容量。

5.5 在线判题平台显示格式错误或答案错误

现象：本地运行结果完全正确，交到在线判题平台（常说的 OJ）却报格式错误或答案错误。原因：多半是输出格式与题目要求不完全一致，比如多打印了空格、换行顺序不对、负号位置放错，或者输入是连续多组数据而程序只处理了一组。解决：先逐字符比对平台给的样例输出，确认空格和换行；再确认负号的输出格式，题目要求-15还是15；最后检查是不是需要循环读取输入直到结束。这个坑无关算法，纯粹是读题不够仔细，但却是扣分最狠的。

6. 把同一个栈复用出去：回文判断、递归改写和可测试的小习惯

6.1 回文判断：复用同一套栈操作代码

栈能解决的场景远不止数制转换。判断一个字符串是不是回文，思路是把所有字符压栈，再依次弹出，和原字符串从左到右比较。弹出的顺序是反的，正好和原字符串形成对照，这就是栈的逆序能力。

int isPalindrome(const char *str) { Stack s; initStack(&s); int len = 0; while (str[len] != '\0') len++; for (int i = 0; i < len; i++) { push(&s, str[i]); /* 字符按 int 存储，取值时再转回 char */ } for (int i = 0; i < len; i++) { int ch; pop(&s, &ch); if (ch != str[i]) { return 0; } } return 1; }

这套代码和数制转换的模板几乎一样：初始化、入栈、出栈、比较。区别只在入栈的数据类型从整数变成了字符，数据结构本身完全没动。这也说明栈操作函数一旦写好，换场景只是改数据来源和比较逻辑的事。

6.2 用递归重写一遍：理解系统栈与显式栈的等价

递归和栈本质上是一回事。递归调用时，系统会自动把每次调用的局部状态压进调用栈，返回时再弹出。数制转换用递归写，看起来完全不需要自己管理栈：

void convertRecursive(long long n, int base) { static const char digits[] = "0123456789ABCDEF"; if (n > 0) { convertRecursive(n / base, base); printf("%c", digits[n % base]); } }

注意printf放在递归调用之后，也就是等内层递归全部返回才执行当前层的打印。这样最里层的调用先打印，正好把余数从低位往高位输出，效果和显式栈完全一致。理解这条等价关系后，你会更清楚递归的调用过程，也更能理解为什么递归不适合特别深的场景——系统栈的容量是有限的，递归层数太深会栈溢出。这是数制转换之外真正值得带走的知识点。

6.3 养成用边界输入清单验证的小习惯

我写栈相关代码时，会先列一张输入清单：0、1、-1、最大值、最小值、超大进制。每个都跑一遍，确认输出符合预期再提交。早年写转换代码只测了 255，后来在调试一个负数用例时熬到深夜，才发现是取模行为的问题。从那以后，边界清单成了我写任何数据结构的默认习惯。希望帮到你。

本文还有配套的精品资源，点击获取