理论准备
C++中的类C可变形参函数
首先，我们来看一下C++中的类C可变形参函数。可变形参函数，表示函数形参的类型和个数都可以变化。C语言中的 printf, scanf 就是最常见的可变形参函数。为了和C语言兼容互通，C++引入了省略符形参。通常，声明一个可变形参函数为如下的形式：
void printf(const char* format,...);
void printf(const char* format...); // 和上面的声明是一样的，即逗号是可选的谈到了可变形参函数，就不得不提一下下面这四个宏定义：
std::va_list va_start va_arg va_end
所有的这些宏都定义在头文件<cstdarg>中。
1.std::va_list
std::va_list typedef 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细讲一下：定义_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可以看出，宏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从宏的定义可以看出，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 ANSI
mode, 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 ANSI
mode, 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++;
}
else
std::cout << (*PtrFmt++);
}
va_end(vp);
}通过对上述内容的了解，我们发现，对于上述可变长参数，只有调用者才知道传进来几个参数，也就是说只有调用者才能维持栈平衡。C的这种可变长方案等于是开了个后门，编译器居然不知道传进来的参数是什么类型。所以在C++11里面专门提供了对可变长参数的更现代化的支持，那就是可变长模板。
可变长模板函数
我们把可变数目的参数称为参数包，通常有两种：模板参数包和函数参数包。分别表示零个或多个参数。
在一个模板参数列表中，class...或typename...指出接下来的参数表示零个或多个类型的列表。
举个例子，
template <typename T, typename... Args>
void foo(const T&t,const 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);
}//包中除了最后一个元素，其他元素都会调用这个版本的print
template <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_FILE
void 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');
else
std::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 ANSI
mode, 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 ANSI
mode, 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++;
}
else
std::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!
8655
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
