大家好，欢迎来到IT知识分享网。

一、常见面试题

1 . 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

​ #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL

#define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）
懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。意识到这个表达式将使一个16位机的整型数溢出，因此要用到长整型符号L,告诉编译器这个常数是的长整型数。如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要

2 . 写一个”标准”宏MIN ，这个宏输入两个参数并返回较小的一个。

​ #define MIN(A,B) （（A） <= (B) ? (A) : (B))

标识#define在宏中应用的基本知识。这是很重要的。因为在 嵌入(inline)操作符 变为标准C的一部分之前，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。
三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。 懂得在宏中小心地把参数用括号括起来 我也用这个问题开始讨论宏的副作用

例如：当你写下面的代码时会发生什么事？
least = MIN(*p++, b);

3. 预处理器标识#error的目的是什么？

停止编译并显示错误信息

编译程序时，只要遇到 #error 就会跳出一个编译错误，既然是编译错误，要它干嘛呢？其目的就是保证程序是按照你所设想的那样进行编译的。

下面举个例子：
程序中往往有很多的预处理指令
#ifdef XXX
…
#else

#endif

当程序比较大时，往往有些宏定义是在外部指定的（如makefile），或是在系统头文件中指定的，当你不太确定当前是否定义了 XXX 时，就可以改成如下这样进行编译：

#ifdef XXX
…
#error “XXX has been defined”

#else

#endif

这样,如果编译时出现错误,输出了XXX has been defined,表明宏XXX已经被定义了。

4.数据声明

用变量a给出下面的定义
a) 一个整型数（An integer）
b)一个指向整型数的指针（ A pointer to an integer）
c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r
d)一个有10个整型数的数组（ An array of 10 integers）
e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers）
f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers）
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）

a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

5.static

关键字static的作用是什么？
在C语言中，关键字static有三个明显的作用：
1.在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

2.在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

3.在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

6.const

关键字const有什么含意？
只要一听到被面试者说：“const意味着常数”，就知道正在和一个业余者打交道。Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着”只读”就可以了。尽管这个答案不是完全的答案，但可以接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）What const Really Means

下面的声明都是什么意思？

 const int a;
 int const a;
 const int *a;
 int * const a;
 int const * a const;

前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。

顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
1 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）
2通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
3合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

7.volatile

关键字volatile有什么含意?并给出三个不同的例子。
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

1.并行设备的硬件寄存器（如：状态寄存器）

2.一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)

3.多线程应用中被几个任务共享的变量

搞嵌入式的经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。下面有几个问题来测试volatile完全的重要性。
1.一个参数既可以是const还可以是volatile吗？解释为什么。

2.一个指针可以是volatile 吗？解释为什么。

3.下面的函数有什么错误：

 int square(volatile int *ptr)
 { 
   
     return *ptr * *ptr;
 }

下面是答案：
1)是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

2)是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。

3)这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

 int square(volatile int *ptr) 
 { 
   
   int a,b;
   a = *ptr;
   b = *ptr;
   return a * b;
 }

由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

 long square(volatile int *ptr) 
 { 
   
   int a;
   a = *ptr;
   return a * a;
 }

8.位操作（Bit manipulation）

嵌入式系统总是要用户对变量或寄存器进行位操作

给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。

在以上两个操作中，要保持其它位不变。

对这个问题有三种基本的反应
1)不知道如何下手。该被面者从没做过任何嵌入式系统的工作。

2)用bit fields。Bit fields是被扔到C语言死角的东西，它保证你的代码在不同编译器之间是不可移植的，同时也保证了的你的代码是不可重用的

3)用 #define 和 bit masks 操作。这是一个有极高可移植性的方法，是应该被用到的方法。最佳的解决方案如下：

 \#define BIT3 (0x1 << 3)
 static int a;

 void set_bit3(void) 
 { 
   
   a |= BIT3;
 }
 void clear_bit3(void) 
 { 
   
   a &= ~BIT3;
 }

一些人喜欢为设置和清除值而定义一个掩码同时定义一些说明常数，这也是可以接受的。

要点：说明常数、|=和&=~操作。

9.访问固定的内存位置（Accessing fixed memory locations）

嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。

在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。

编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。
这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下：

   int *ptr;
   ptr = (int *)0x67a9;
   *ptr = 0xaa55;

A more obscure approach is:
一个较晦涩的方法是：

*(int * const)(0x67a9) = 0xaa55;

即使你的品味更接近第二种方案，但我建议你在面试时使用第一种方案。

10.中断（Interrupts）

中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字 __interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR)，请评论一下这段代码的。

 __interrupt double compute_area (double radius) 
 { 
   
   double area = PI * radius * radius;
   printf("\nArea = %f", area);
   return area;
 }

这个函数有太多的错误了，以至让人不知从何说起了：
1)ISR 不能返回一个值。如果你不懂这个，那么你不会被雇用的。

2)ISR 不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。

3)在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈**，有些处理器/编译器就是不允许在ISR中做浮点运算**。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。

4)与第三点一脉相承，printf()经常有重入和性能上的问题。如果你丢掉了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了。

printf()经常有重入解释：

**不可重入函数不可以在它还没有返回就再次被调用。**例如printf，malloc，free等都是不可重入函数。因为中断可能在任何时候发生，例如在printf执行过程中，因此不能在中断处理函数里调用printf，否则printf将会被重入。

函数不可重入大多数是因为在函数中引用了全局变量。例如，printf会引用全局变量stdout，malloc，free会引用全局的内存分配表。
**不可重入函数指的是该函数在被调用还没有结束以前，再次被调用可能会产生错误。**可重入函数不存在这样的问题。不可重入函数在实现时候通常使用了全局的资源，在多线程的环境下，如果没有很好的处理数据保护和互斥访问，就会发生错误。
常见的不可重入函数有：
printf ———引用全局变量stdout
malloc ——–全局内存分配表
free ———–全局内存分配表
在unix里面通常都有加上_r后缀的同名可重入函数版本。如果实在没有，不妨在可预见的发生错误的地方尝试加上保护锁同步机制等等。

二、代码例子（Code examples）

1.下面的代码输出是什么，为什么？（自动转换）

 void foo(void)
 { 
   
   unsigned int a = 2;
   int b = -20;
   (a+b > 20) ? puts("> 20") : puts("<= 20");
 }

这个问题测试你是否懂得C语言中的整数自动转换原则，这无符号整型问题的答案是输出是 “>20”。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于20。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。

转换分为隐式转换和运算符转换
1、隐式转换
C在以下四种情况下会进行隐式转换:
1、算术运算式中，低类型能够转换为高类型。
2、赋值表达式中，右边表达式的值自动隐式转换为左边变量的类型，并赋值给他。
3、函数调用中参数传递时，系统隐式地将实参转换为形参的类型后，赋给形参。
4、函数有返回值时，系统将隐式地将返回表达式类型转换为返回值类型，赋值给调用函数。

2、算数运算的隐式转换
算数运算中，首先有如下类型转换规则：
1、字符必须先转换为整数(C语言规定字符类型数据和整型数据之间可以通用) 。
2、short型转换为int型(同属于整型) 。
3、float型数据在运算时一律转换为双精度(double)型，以提高运算精度(同属于实型) 。

2.动态内存分配（Dynamic memory allocation）

嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？
这里，我期望应试者能提到内存碎片，碎片收集的问题，变量的持行时间等等。这个主题已经在ESP杂志中被广泛地讨论过了（主要是 P.J. Plauger, 他的解释远远超过我这里能提到的任何解释），所有回过头看一下这些杂志吧！让应试者进入一种虚假的安全感觉后，我拿出这么一个小节目：
下面的代码片段的输出是什么，为什么？

char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts(“Got a null pointer”);
else
puts(“Got a valid pointer”);

这就是上面的代码，该代码的输出是”Got a valid pointer”。我用这个来开始讨论这样的一问题，看看被面试者是否想到库例程这样做是正确。得到正确的答案固然重要，但解决问题的方法和你做决定的基本原理更重要些。

3.Typedef

Typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子：

 #define dPS struct s *
 typedef struct s * tPS;

以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？
这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。

答案是：typedef更好。思考下面的例子：

dPS p1,p2;
tPS p3,p4;

第一个扩展为

struct s * p1, p2;
.
上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。

4.晦涩的语法

C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？

int a = 5, b = 7, c;
c = a+++b;

这个问题将做为这个测验的一个愉快的结尾。不管你相不相信，上面的例子是完全合乎语法的。问题是编译器如何处理它？水平不高的编译作者实际上会争论这个问题，根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理成：

c = a++ + b;

这段代码执行后a = 6, b = 7, c = 12。

5.面试题（嵌入式）

1.static变量和static 函数各有什么特点？

• static变量

1. static关键字修饰变量叫的静态变量
2. static修饰局部变量，这个变量从定义开始被分配到数据段中，直到程序结束才释放空间，且只初始化一次
3. static关键字修饰的全局变量，这个全局变量只在当前文件有效

• static函数

1. 其他文件中可以定义相同名字的函数，不会发生冲突
2. 静态函数不能被其他文件所用

2.描述一下嵌入式基于ROM的运行方式基于RAM的运行方式有什么区别。

ROM的特点是速度慢价格低，掉电不丢失

RAM是速度快，价格高，字节存取。

芯片复位一定是从ROM开始的，然后一些操作为了获得更快的处理速度和一些特殊处理。将ROM的代码拷贝到RAM然后转到RAM执行。

RAM与ROM区别（详细）

• 内存RAM (Random Access Memory)

1. SRAM (Static RAM)
   1. 静态RAM（SRAM），它的执行速度非常快，是目前读写最快的存储设备，价格非常昂贵，所以只在要求很苛刻的地方使用，譬如CPU的一级、二级缓存。
   2. 特点是不需要程序来初始化，上电就可以使用。
2. DRAM (Dynamic RAM)
   1. 动态RAM（DRAM）保留数据的时间短，速度比SRAM慢，比ROM都快，DRAM比SRAM要便宜很多，计算机内存就是DRAM。特点是上电后需要软件初始化，才能使用。
   2. DRAM分为很多种，常见的主要有FPRAM / FastPage、EDORAM、SDRAM、DDR RAM、RDRAM、SGRAM以及WRAM等。
   3. DDR RAM（Double-Date-Rate RAM）也称作DDR SDRAM，这种改进型的RAM和SDRAM是基本一样的，不同之处在于它可以在一个时钟期间读写两次数据，这样就使得数据传输速度加倍。

51系列单片机，stm32单片机等，它对内存的需求小，同时为了降低开发难度，适合使用SRAM。它们的结合是SRAM+NORFlash,所以单片机上电从来不初始化内存就是这个原因

电脑对内存的开销要求大，适合全部使用DRAM。它一般组合是NORFlash（BIOS）+DRAM+硬盘

嵌入式系统,两种方式，一是NORFlash+NAND方式，二是NAND+DRAM+CPU内置的SRAM。后一种方式便宜，所以很多厂商使用后面的配置。

• 外部存储器ROM (Read Only Memory)

1. PROM (Programmable Read-Only Memory)-可编程只读存储器,也叫One-Time Programmable (OTP)ROM“一次可编程只读存储器”
2. EPROM就是Erasable Programmable Read Only Memory，含意为“可擦除可编程只读存储器”。它是一种可重写的存储器芯片，并且其内容在掉电的时候也不会丢失。是通过紫外光的照射擦除程序。
3. EEPROM (Electrically Erasable Programmable read only memory)是指带电可擦可编程只读存储器。是一种掉电后数据不丢失的存储芯片。 EEPROM 可以在电脑上或专用设备上擦除已有信息，重新编程。它的价格很高，写入时间很长，写入很慢。

• Flash存储器

FLASH 存储器又称闪存，它结合了ROM和RAM的长处，不仅具备电子可擦除可编程(EEPROM)的性能，还不会断电丢失数据同时可以快速读取数据(NVRAM 的优势)。过去的20年，嵌入式系统一直使用ROM (EPROM)作为它们的存储设备，近年来Flash全面代替了ROM (EPROM)在嵌入式系统中的地位，用作存储Bootloader以及操作系统或者程序代码或者直接当硬盘使用（U盘）。 目前Flash主要有两种NOR Flash和NAND Flash。

• NOR Flash

1. NOR Flash 非易失性存储器。的传输效率很高，在1~4MB的小容量时具有很高的成本效益，但是很低的写入和擦除速度大大影响到它的性能，NOR flash占据了容量为1～16MB闪存市场的大部分。
2. 特点： 芯片内执行（XIP ，eXecute In Place），它和CPU直接总线相连，上电就可以执行程序，不需要初始化芯片，同时，程序可以直接在Flash闪存内运行，不必再把代码读到系统RAM中。一般嵌入式中用它做启动介质。

• NAND Flash

1. Nand-flash存储器是flash存储器的一种，为固态大容量内存的实现提供了廉价有效的解决方案。Nand-flash存储器具有容量较大，改写速度快等优点，适用于大量数据的存储，因而在业界得到了越来越广泛的应用，如嵌入式产品中包括数码相机、MP3随身听记忆卡、体积小巧的U盘等。
2. 特点：上电需要初始化后才能使用，NAND器件使用复杂的I/O口来串行地存取数据，各个产品或厂商的方法可能各不相同，8个引脚用来传送控制、地址和数据信息。

NOR Flash和NAND Flash 比较：

1. NOR的读速度比NAND稍快一些。
2. NAND的写入速度比NOR快很多。
3. NOR flash带有SRAM接口，有足够的地址引脚来寻址，可以很容易地存取其内部的每一个字节。
4. NAND读和写操作采用512字节的块，这一点有点像硬盘管理此类操作，很自然地，基于NAND的存储器就可以取代硬盘或其他块设备。

3.task 有几种状态？

​

4.task 有几种通讯方式？

5.C函数允许重入吗？

6.嵌入式操作系统和通用操作系统有什么差别？

7.将一个字符串逆序

// 将一个字符串逆序 
void swap(char *a,char *b)
{ 
   
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void ReverseStr(char *s,int len)
{ 
   
	int size = len;
	for(int i=0;i < size/2 ; i++)
	{ 
   
		len--;
		swap(s+i,s+len);
	}
}

8.将一个链表逆序

/* 迭代法： 1. 需要三个指针，prev，cur，next（保存cur->next） 2. prev指向上一个节点，cur指向当前节点，next指向下一个节点 3. 最初prev指向NULL，cur指向头节点 4. next指针保存cur->next，防止链表断开 5. 将cur的next指向上一个节点（prev） 6. prev再指向当前节点（cur） 7. cur再指向下一个节点（next） 8. 再循环4-7，直到cur为NULL */
struct ListNode* reverseList(struct ListNode* head)
{ 
   
	struct ListNode* prev = NULL;
    struct ListNode* cur = head;
    while(cur)
    { 
   
        struct ListNode* next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }
}

9.计算一个字节里（byte）里面有多少bit被置1

10.搜索给定的字节(byte)

11字符串匹配（KMP）

#include <stdio.h> 
#include <stdlib.h>
#include <string.h>
#include <assert.h>

int *next;

int * GetNext(char* p)
{ 
   
    int pLen = strlen(p);
    next = calloc(pLen+1,sizeof(int));
    next[0] = -1;
    int k = -1;
    int j = 0;
    while (j < pLen - 1)
    { 
   
        //p[k]表示前缀，p[j]表示后缀
        if (k == -1 || p[j] == p[k]) 
        { 
   
            ++k;
            ++j;
            next[j] = k;
        }
        else 
        { 
   
            k = next[k];
        }
    }
    return next;
}
int KmpSearch(char* s, char* p)
{ 
   
    int i = 0;
    int j = 0;
    int sLen = strlen(s);
    int pLen = strlen(p);
    while (i < sLen && j < pLen)
    { 
   
        //①如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++ 
        if (j == -1 || s[i] == p[j])
        { 
   
            i++;
            j++;
        }
        else
        { 
   
            //②如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j] 
            //next[j]即为j所对应的next值 
            j = next[j];
        }
    }
    if (j == pLen)
        return i - j;
    else
        return -1;
}

int main()
{ 
   
    char str[]="hasddsaabababbs";
    char substr[]="abababb";
    GetNext(substr);
    int ret = KmpSearch(str,substr);
    printf("%d\n",ret);
    free(next);
    return 0;
}

12.字符串转换为整数

#include <ctype.h>

int  StringToInt(const char *nptr)
{ 
   
    return (int)StringToLong(nptr);
}
 
long  StringToLong(const char *nptr)
{ 
   
    int c;              /* 当前要转换的字符(一个一个字符转换成数字) */
    long total;         /* 当前转换结果 */
    int sign;           /* 标志转换结果是否带负号*/

    /*跳过空格，空格不进行转换*/
    while ( isspace((int)(unsigned char)*nptr) )
        ++nptr;

    c = (int)(unsigned char)*nptr++;//获取一个字符准备转换 
    sign = c;           /*保存符号标示*/
    if (c == '-' || c == '+')
        c = (int)(unsigned char)*nptr++;    /*跳过'+'、'-'号，不进行转换*/

    total = 0;//设置转换结果为0 

    while (isdigit(c)) { 
   //如果字符是数字 
        total = 10 * total + (c - '0');     /* 根据ASCII码将字符转换为对应的数字，并且乘10累积到结果 */
        c = (int)(unsigned char)*nptr++;    /* 取下一个字符 */
    }

	//根据符号指示返回是否带负号的结果 
    if (sign == '-')
        return -total;
    else
        return total;  
}

13.整数转换为字符串

char* IntToString(int num,char *str,int radix)	
{ 
   
	char index[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";//索引表
	unsigned unum;//存放要转换的整数的绝对值,转换的整数可能是负数
	int i=0,j,k;//i用来指示设置字符串相应位，转换之后i其实就是字符串的长度；
	// 转换后顺序是逆序的，有正负的情况，k用来指示调整顺序的开始位置;j用来指示调整顺序时的交换。

	//获取要转换的整数的绝对值
	if(radix == 10 && num < 0)//要转换成十进制数并且是负数
	{ 
   
		unum=(unsigned)-num;//将num的绝对值赋给unum
		str[i++]='-';//在字符串最前面设置为'-'号，并且索引加1
	}
	else unum=(unsigned)num;//若是num为正，直接赋值给unum

	//转换部分，注意转换后是逆序的
	do
	{ 
   
		str[i++]=index[unum%(unsigned)radix];//取unum的最后一位，并设置为str对应位，指示索引加1
		unum/=radix;//unum去掉最后一位
 
	}while(unum);//直至unum为0退出循环

	str[i]='\0';//在字符串最后添加'\0'字符，c语言字符串以'\0'结束。

	//将顺序调整过来
	if(str[0]=='-') k=1;//如果是负数，符号不用调整，从符号后面开始调整
	else k=0;//不是负数，全部都要调整

	char temp;//临时变量，交换两个值时用到
	for(j=k;j<=(i-1)/2;j++)//头尾一一对称交换，i其实就是字符串的长度，索引最大值比长度少1 //字符串翻转
	{ 
   
		temp=str[j];//头部赋值给临时变量
		str[j]=str[i-1+k-j];//尾部赋值给头部
		str[i-1+k-j]=temp;//将临时变量的值(其实就是之前的头部值)赋给尾部
	}
 
	return str;//返回转换后的字符串
}