用C和C++，两种方式实现C语言中的printf函数

理论准备

C++中的类C可变形参函数

首先，我们来看一下C++中的类C可变形参函数。可变形参函数，表示函数形参的类型和个数都可以变化。C语言中的 printf, scanf 就是最常见的可变形参函数。为了和C语言兼容互通，C++引入了省略符形参。通常，声明一个可变形参函数为如下的形式：

void printf(const char* format,...);void printf(const char* format...); // 和上面的声明是一样的，即逗号是可选的

虽然C++中允许使用类似void printf(...);这样的定义，不过还是保留第一个格式形参比较好。这样有通用性。

谈到了可变形参函数，就不得不提一下下面这四个宏定义：

std::va_list va_start va_arg va_end

所有的这些宏都定义在头文件<cstdarg>中。

1.std::va_list

std::va_listtypedef char*  va_list; //Defined in header <cstdarg>

va_list就是char*的别名。不过在有些系统中，va_list定义的是void*。

2.va_start

va_start:#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )#define _crt_va_start(ap,v)  ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )#define va_start _crt_va_start

void va_start( va_list ap, parm_n ); 将第一个可变形参的首地址，赋给ap，其中 parm_n 是最后一个固定形参。

细讲一下：定义_INTSIZEOF(n)主要是为了兼容某些需要内存对齐的系统。这个宏的目的是为了得到每一个参数在栈中的实际内存大小。

_ADDRESSOF(v)是最后一个固定参数的地址，_INTSIZEOF(v)是最后一个固定参数所占的内存大小。二者求和，即为栈中第一个可变形参的首地址。

3.va_arg

va_arg：#define _crt_va_arg(ap,T)    ( *(T *)((ap += _INTSIZEOF(T)) - _INTSIZEOF(T)) )#define va_arg _crt_va_arg

T va_arg( va_list ap, T );
可以看出，宏va_arg有两个作用，一是返回指针ap所指向的变量的内容，T为该变量的类型；二是将ap指向形参栈中下一个可变形参。(栈是向低地址扩展的数据结构，是一块连续的内存的区域)

4.va_end

va_end:#define _crt_va_end(ap)      ( ap = (va_list)0 )#define va_end _crt_va_end

void va_end( va_list ap );
从宏的定义可以看出，va_end的作用就是将ap置为空指针(nullptr)，使ap不再指向任何有效内存。

对于va_arg宏的使用有两个比较关键的点,第一个是可变形参的参数个数，第二个是可变形参的参数类型。va_arg要根据参数的类型去寻址，若知道参数的个数和参数的类型,则可变参函数的实现较为简单。我们知道，函数的形参都是从右向左依次入栈的，第一个形参在栈的最上面。只要获得第一个形参的地址、每个形参的类型和总形参的个数，其他的就水到渠成了。

void MyPrint(const char* fmt, ...){double vargFlt = 0;int  vargInt = 0;const char* vargPtrChar = nullptr;char vargChar = 0;const char* PtrFmt = nullptr;va_list vp;va_start(vp, fmt);PtrFmt = fmt;while(*PtrFmt) {if(*PtrFmt == '%') {switch(*(++PtrFmt)) {case 'c':vargChar = va_arg(vp, int);/*    va_arg(ap, type), if type is narrow type (char, short, float) an error is given in strict ANSImode, or a warning otherwise.In non-strict ANSI mode, 'type' is allowed to be any expression. */std::cout << (vargChar);break;case 'd':case 'i':vargInt = va_arg(vp, int);printDec(vargInt);break;case 'f':vargFlt = va_arg(vp, double);/*    va_arg(ap, type), if type is narrow type (char, short, float) an error is given in strict ANSImode, or a warning otherwise.In non-strict ANSI mode, 'type' is allowed to be any expression. */printFlt(vargFlt);break;case 's':vargPtrChar = va_arg(vp, const char*);std::cout << (vargPtrChar);break;case 'b':case 'B':vargInt = va_arg(vp, int);printBin(vargInt);break;case 'x':case 'X':vargInt = va_arg(vp, int);printHex(vargInt);break;case '%':std::cout << ('%');break;default:break;}PtrFmt++;}elsestd::cout << (*PtrFmt++);}va_end(vp);}

通过对上述内容的了解，我们发现，对于上述可变长参数，只有调用者才知道传进来几个参数，也就是说只有调用者才能维持栈平衡。C的这种可变长方案等于是开了个后门，编译器居然不知道传进来的参数是什么类型。所以在C++11里面专门提供了对可变长参数的更现代化的支持，那就是可变长模板。

可变长模板函数

我们把可变数目的参数称为参数包，通常有两种：模板参数包和函数参数包。分别表示零个或多个参数。
在一个模板参数列表中，class...或typename...指出接下来的参数表示零个或多个类型的列表。

举个例子，

template <typename T, typename... Args>void foo(const T&t,const Args&... rest);

在这个例子中，Args是一个模板参数包；rest是一个函数参数包。

一个参数包后加...表示包扩展。对于每个扩展元素，我们还可以提供模式。
Args...就是包扩展。 const Args&就是模式。比如：

int i = 0; double d = 3.14; string s = "how are you";
foo(i, s, 42, d);

编译器会把上述foo实例化为
void foo(const int&, const string&, const int&, const double&);

而对于不同的函数调用，生成不同的实例化版本。
foo(s, 42, "hi");
编译器会把上述foo实例化为
void foo(const string&, const int&, const char[3]&);

sizeof...运算符
当我们需要知道包中有多少元素时，就可以使用sizeof...运算符。

template <typename ... Args>void g(Args... funcArgs) {std::cout << sizeof...(Args) << std::endl;std::cout << sizeof...(funcArgs) << std::endl;}

看完了声明，我们再来看看可变长模板函数是怎么实现的。

我们就以要实现的 print 函数为例来讲一下。

C++可变参数函数模板通常是递归的，通过特化来实现了递归，每递归一次就得到一个类型。第一步处理包中的第一个实参，然后用剩余实参调用自身，每递归一次就得到一个新的函数类型。为了终止递归，我们还要定义一个非可变参数的print函数，它接受一个流和一个对象：

template <typename T>ostream& print(ostream& os, const T& t) {return (os << t);}

//包中除了最后一个元素，其他元素都会调用这个版本的printtemplate <typename T, typename... Args>ostream& print(ostream& os, const T& t, const Args&... funcRest) {os << t << ", ";print(ostream& os, funcRest...);}

最后，再补充一下模式。
当然，还有更复杂的扩展模式。例如，我们对每个实参调用showMe函数。

template <typename T> string showMe(const T& t) {ostringstream ret;ret << t;return ret.str();}

然后调用print打印结果string：

template <typename... Args>ostream&errorMsg(ostream& os, const Args... funRest) {return print(os, showMe(funRest)...);}

变长模板优点

• 在模板推导，也就是编译的时候，就已经可以确知参数的类型和个数了，可以进行类型检查，同时，存在代码优化的可能。
• 既然编译器可以确知参数类型和个数，那么调用约定也就没有存在的必要了。

实际代码展示

1.C++中的类C可变形参函数

//print.h#ifndef PRINT_HEAD_FILE#define PRINT_HEAD_FILEvoid MyPrint(const char* fmt, ...);void printDec(int dec);void printFlt(double flt);void printBin(int bin);void printHex(int hex);#endif // PRINT_HEAD_FILE

//print.cpp#include <iostream>#include <cstdarg>void printDec(int dec) {if(dec==0)return;printDec(dec/10);std::cout << (char)(dec%10 + '0');}void printFlt(double flt) {int tmpint = 0;tmpint = (int)flt;printDec(tmpint);std::cout << '.';flt = flt - tmpint;tmpint = (int)(flt * 10000000000);printDec(tmpint);}void printBin(int bin) {if(bin == 0) {std::cout << "0b";return;}printBin(bin/2);std::cout << (char)(bin%2 + '0');}void printHex(int hex) {if(hex==0) {std::cout << "0x";return;}printHex(hex/16);hex = hex % 16;if(hex < 10)std::cout << (char)(hex + '0');elsestd::cout << (char)(hex - 10 + 'A');}void MyPrint(const char* fmt, ...){double vargFlt = 0;int  vargInt = 0;const char* vargPtrChar = nullptr;char vargChar = 0;const char* PtrFmt = nullptr;va_list vp;va_start(vp, fmt);PtrFmt = fmt;while(*PtrFmt) {if(*PtrFmt == '%') {switch(*(++PtrFmt)) {case 'c':vargChar = va_arg(vp, int);/*    va_arg(ap, type), if type is narrow type (char, short, float) an error is given in strict ANSImode, or a warning otherwise.In non-strict ANSI mode, 'type' is allowed to be any expression. */std::cout << (vargChar);break;case 'd':case 'i':vargInt = va_arg(vp, int);printDec(vargInt);break;case 'f':vargFlt = va_arg(vp, double);/*    va_arg(ap, type), if type is narrow type (char, short, float) an error is given in strict ANSImode, or a warning otherwise.In non-strict ANSI mode, 'type' is allowed to be any expression. */printFlt(vargFlt);break;case 's':vargPtrChar = va_arg(vp, const char*);std::cout << (vargPtrChar);break;case 'b':case 'B':vargInt = va_arg(vp, int);printBin(vargInt);break;case 'x':case 'X':vargInt = va_arg(vp, int);printHex(vargInt);break;case '%':std::cout << ('%');break;default:break;}PtrFmt++;}elsestd::cout << (*PtrFmt++);}va_end(vp);}

测试函数：

//testMain.cpp#include "print.h"int main() {int iNum1 = 10;int iNum2 = 0x1d;MyPrint("%d,%x, %s \nThe End!",iNum1,iNum2,"Hello World!");return 0;}

测试输出结果为：

10,0x1D, Hello World!The End!

2.可变长模板函数

//print.h#ifndef PRINT_HEAD_FILE#define PRINT_HEAD_FILE#include <iostream>using std::ostream;template <typename T>ostream& myPrint(ostream& os, const T& t) {return (os << t << '\n');}template <typename T, typename... Args>ostream& myPrint(ostream& os, const T& t, const Args&... funcRest) {os << t << ",  ";myPrint(os, funcRest...);return os;}#endif // PRINT_HEAD_FILE

测试函数：

//testMain.cpp#include <iostream>#include "print.h"#include <string>int main() {int iNum = 10;char myChar = 'G';std::string myStr = "What's important!";double myDbl = 8.88;myPrint(std::cout, iNum, myChar, myStr, myDbl);return 0;}

Done!