可变参数列表与printf的实现

最新推荐文章于 2022-11-18 20:25:08 发布
最新推荐文章于 2022-11-18 20:25:08 发布
阅读量221 收藏
点赞数
分类专栏： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39290388/article/details/81301427
版权

先来两个认知：①c语言函数参数压栈的是从右往左开始的。

                         ②可变参函数压参数进栈时，每个参数栈4k个字节。(k=1，2，3，4，5，6...)

 

    有了上面的认知之后，剩下的问题就是按照我们自己的意愿去访问栈中的元素。当然了，凭我们自己90%不知道栈在哪里，

不知道如何指向栈顶。那么用下面的宏就可以帮我们找到栈了

        先定义一个va_list类型的变量 arg，他用于访问参数列表的未确定部分。

       ①va_start(arg,v) //v是整个参数里面的第一个参数。通过va_start来初始化arg变量，即这一步的目的是为了让指针arg跳过参数v,使得arg指向可变参(即...)的第一个参数。

      ②va_arg(arg,t)//t是可变参的类型。这步是在访问可变参。(有地址，有类型，当然可以访问到可变参了)

      ③va_end(arg)//这步是为了将arg指针置空。

 

一. 下面的代码是利用可变参来求未知个数整型的平均值。（先来个开胃小菜）

#include <stdio.h>
#include <stdarg.h>

int average(int n, ...)
{
    va_list arg;
    int i = 0;
    int sum = 0;
    va_start(arg, n);
    for(i=0; i<n; i++)
    {
        sum += va_arg(arg, int);
    }
    return sum/n;
    va_end(arg);
}

int main()
{
    int a = 1;
    int b = 2;
    int c = 3;
    int avg1 = average(2, a, c);
    int avg2 = average(3, a, b, c);
    printf("avg1 = %d\n", avg1);
    printf("avg2 = %d\n", avg2);
    return 0;
}

     

         好了，下面是printf函数的代码。

       附：printf的实现大体跟上面的做法差不多，复杂就复杂在它的格式控制哦

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include<CoreWindow.h>
#include<cctype>

void f1(size_t i, char ch)
{
	int base = 10;
	static char arr[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
	if (!i)return;
	else
	{
		if (ch == 'o')
			base = 8;
		else if (ch == 'x' || ch == 'X' || ch == 'p')
			base = 16;
		f1(i / base, ch);
	}
	if (ch == 'p')
	{
		if (isdigit(arr[i % base]))
			putchar(arr[i % base]);
		else
			putchar(arr[i % base] - 32);
	}
	else
		putchar(arr[i % base]);
}


//%c %d %i %u %f %o %x/X %p %s %%  (%a/A %e/E  %g/G) %n
void print5(const char*format, ...)
{
	va_list arg;
	va_start(arg, format);
	while (*format)
	{
		if (*format == '%') // % +0m.n c   (% ch1 ch2 m.n c)
		{
			char ch1 = ' ', ch2 = ' ', ch3 = ' ', ch = ' ';
			int m = 0, n = 0;
			while (isdigit(*++format) || *format == '+' || *format == '-' || *format == '#' || (*format == '.' && isdigit(*(format + 1))))
			{//让数字，+，-，#，点号，进入循环。                                                //点号后面必须是数字
				switch (*format)
				{
				case'+':
				{
						   if (ch1 != '-')ch1 = '+';
						   break;
				}
				case'-':
				{
						   ch1 = '-';//有'-'，则优先给ch1赋值为'-'。
						   break;
				}
				case'#'://只对o和x起作用 //对于o类，在输出时加前缀0；对于x类，在输出时加前缀0x。
				{
							ch3 = '#';
				}
				case'0'://ch1表示'+','-'；ch2表示'0','空'
				{
							if (!isdigit(*(format - 1)))//如果*format=='0'时，前一个字符不是数字(不包括'0')
							{
								//ch1 = '-';
								ch2 = '0';
								break;
							}//'0','+'混合情况(输出+000xxxx)；'0','-',('+')混合情况(输出+xxxx)。
				}
					//在处理m,n时，已经将ch1和ch2处理好了。
				case'1':
				case'2'://m表示域宽，即对应的输出项在输出设备所占字节数
				case'3':       //指定占字节数m 与 实际占字节数，输出项在输出设备所占字节数取二者最大值
				case'4'://n表示精度，主要用于说明输出的实型数的小数位数
				case'5':      //对于整型15：①%6.2d->    15；②%6.4d->  0015；③%6.8d->000015
				case'6':
				case'7':
				case'8':
				case'9':
				{
						   m = 10 * m + *format - '0';
						   break;
				}
				case'.':
				{
						   ch = *format;
						   while (isdigit(*++format))
							   n = 10 * n + *format - '0';
						   break;
				}
				}
				if (ch == '.')
					break;
			}
			switch (*format)
			{
			case 'c'://输出c时只和域宽m有关。
			{
						 char ch = va_arg(arg, char);
						 if (ch1 == '+'|| ch1 == ' ')
						 while (--m)putchar(ch2);//ch2可以是空，也可以是0.
						 putchar(ch);
						 if (ch1 == '-')
						 while (--m)putchar(' ');
						 break;
			}

			case 'i':
				;
			case 'd':
			{
						int i = va_arg(arg, int);
						if (i < 0)
						{
							putchar('-');
							i = -i;
						}
						int tmp = i, count = 0;
						while (tmp)++count, tmp /= 10;
						n = n > count ? n : count;//保证n是两者最大值
						if (ch1 == '+'|| ch1 == ' ')
						{
							while (--m - n>0)putchar(' ');//若m>n,这步的结果是让m = n；假如m<n，这步无效
							if (i>0 && ch1 != ' ')
								putchar('+');
							while (n - count > 0)--n, putchar('0');//假如n<count，这步无效
						}

						if (ch1 == '-')
						{
							int tmpn = n;;
							while (tmpn-- - count > 0)putchar('0');//假如n<count，这步无效
						}
						f1(i, *format);
						if (ch1 == '-')
						while (m - n>0)--m, putchar(' ');//假如m<n，这步无效
						break;
			}
			case 'u':
			{
						int u = va_arg(arg, unsigned int);
						size_t tmp = u, count = 0;
						while (tmp)++count, tmp /= 10;
						n = n > count ? n : count;//保证n是两者最大值
						if (ch1 == '+' || ch1 == ' ')
						{
							while (--m - n>0)putchar(' ');//若m>n,这步的结果是让m = n；假如m<n，这步无效
							if (u>0 && ch1 != ' ')
								putchar('+');
							while (n - count > 0)--n, putchar('0');//假如n<count，这步无效
						}

						if (ch1 == '-')
						{
							int tmpn = n;
							while (tmpn-- - count > 0)putchar('0');//假如n<count，这步无效
						}
						f1(u, *format);
						if (ch1 == '-')
						while (m - n>0)--m, putchar(' ');//假如m<n，这步无效
						break;
			}
			case 'f':
			{
						double f = va_arg(arg, double);
						if (0x80 & *((char*)(&f + 1) - 1))//判断该浮点数是否为负数
						{//这样写还不如写成:if(f<0)
							putchar('-');
							f = -f;
						}
						int tmp = (int)f,tmp2 = (int)f,count = 0;
						while (tmp)++count, tmp /= 10;
						count += n + 1;
						if (ch1 == '+' || ch1 == ' ')
						{
							if (f>0 && ch1 != ' ')
								putchar('+');
							while (--m - count>0)putchar(ch2);//假如m<count，这步无效
						}
						f1(tmp2, *format);
						putchar('.');

						if (n == 0)n = 6;
						while (n--)f*=10,tmp2 *= 10;
						tmp = f - tmp2;
						f1(tmp, *format);
						if (ch1 == ' ')
						{
							while (m-- - count > 0)putchar(' ');
						}
						break;
			}

			case 'o'://没测试ch2 == '0'的情况
			{
						int o = va_arg(arg, unsigned int);
						size_t tmp = o, count = 0;
						while (tmp)++count, tmp /= 8;
						n = n > count ? n : count;//保证n是两者最大值
						if (ch3 == '#')++n;
						if (ch1 == '+' || ch1 == ' ')
						{
							int tmpm = m;
							while (tmpm-- - n>0)putchar(' ');//假如m<n，这步无效
							if (m && m<n)--n;
							while (n - count > 0)--n, putchar('0');//假如n<count，这步无效
						}

						if (ch1 == '-')
						{
							int tmpn = n;
							while (tmpn-- - count > 0)putchar('0');//假如n<count，这步无效
						}
						f1(o, *format);
						if (m<n)--n;
						if (ch1 == '-')
						while (m - n>0)--m, putchar(' ');//假如m<n，这步无效
						break;
			}
			case'X':
				;
			case 'x'://没测试ch2 == '0'的情况
			{
						int x = va_arg(arg, unsigned);

						size_t tmp = x, count = 0;
						while (tmp)++count, tmp /= 16;
						n = n > count ? n : count;//保证n是两者最大值
						if (ch3 == '#')m -= 2;
						if (ch1 == '+' || ch1 == ' ')
						{
							int tmpm = m;
							while (tmpm-- - n>0)putchar(' ');//假如m<n，这步无效
							if (ch3 == '#')putchar('0'),putchar('x');
							while (n - count > 0)--n, putchar('0');//假如n<count，这步无效
						}

						if (ch1 == '-')
						{
							if (ch3 == '#')putchar('0'), putchar('x');
							int tmpn = n;
							while (tmpn-- - count > 0)putchar('0');//假如n<count，这步无效
						}
						f1(x, *format);
						if (ch1 == '-')
						{
							m -= 1;
							while (m - n>0)--m, putchar(' ');//假如m<n，这步无效
						}
						break;
			}
			case 'p'://没测试ch2 == '0'的情况
			{
						int p = va_arg(arg, unsigned int);
						size_t tmp = p, count = 0;
						while (tmp)++count, tmp /= 16;
						n = 8;
						if (ch1 == '+' || ch1 == ' ')
						{
							int tmpm = m;
							while (tmpm-- - n>0)putchar(' ');//假如m<n，这步无效
							if (ch3 == '#')putchar('0'), putchar('x');
							while (n - count > 0)--n, putchar('0');//假如n<count，这步无效
						}

						if (ch1 == '-')
						{
							if (ch3 == '#')putchar('0'), putchar('x');
							int tmpn = n;
							while (tmpn-- - count > 0)putchar('0');//假如n<count，这步无效
						}
						f1(p, *format);

						if (ch1 == '-')
						{
							m -= 2;
							while (m - n>0)--m, putchar(' ');//假如m<n，这步无效
						}
						break;
			}
			case 's'://没测试ch2 == '0'  和ch3 == '#'的情况
			{
						char *s = va_arg(arg, char*);
						n = (n && n<strlen(s)) ? n : strlen(s);
						if (ch1 == '+' || ch1 == ' ')
						{
							while (m-- - n > 0)putchar(' ');
						}
						for (size_t i = 0; i < n; ++i)
							putchar(*(s + i));
						if (ch1 == '-')
						{
							while (m-- - n > 0)putchar(' ');
						}
						break;
			}
			case '%':
			{
						putchar('%');
						break;
			}
			case'n'://可以将所输出字符串的长度值赋给一个变量。eg.int len;printf("abcdefg%n",&len);
				break;                                        //执行后变量被赋值为7.

			case'a'://浮点数、十六进制数字和p-(P-)计数法
			case'A':
				break;
			case'e'://浮点数指数输出
			case'E':
				break;
			case 'g'://自动选f格式或e格式中较短的一种输出，且浮点数不显示无意义的零
			case 'G':
				break;
			default:
				putchar(*format);
			}
		}
		else
		{
			putchar(*format);
		}
		format++;
	}
	va_end(arg);
}

//已完成:%c %d %i %u %f %o %x/X %p %s %%  未完成:(%a/A %e/E  %g/G) %n
int main()
{
	printf("%%%\n");
	print5("%%%\n");
	system("pause");
	return 0;
}

 

附录，一些不需要掌握的关于可变参的very very very重要的原理：

 

 

 

 

 

皇纸墙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用可变参数实现printf()函数
05-07
通过可变参数函数实现printf()函数功能，可将其应用于单片机，ARM裸机等的串口输出中去，并且新增了[%b:实现二进制输出，原来printf函数不能实现的功能]。也可将其使用的液晶的字符类驱动中去。
printf()可变域宽输出
weixin_30599769的博客
12-10 254
　　在用到格式化I0可变域宽的时候，想到只用一个循环实现最初学c语言时的小练习，打印空心三角形，就实现了一下。 　　printf("%*d\n", m, n)；*表示域宽，值由m确定。就由两个可变域宽实现两条边，遗憾的是顶点与底边还得单独实现。 1 // 只用一次循环,打印空心三角形 2 #include <stdio.h> 3 int main(void) 4...
数据结构—顺序表的基本操作--C语言代码（可运行）
qq_45066397的博客
08-21 2991
1、顺序表的基本操作 使用软件：vs code 基本操作： InitList(SqList*L);//初始化 Length(SqList&L);//求表长 ListInsert(SqList&L,inti,Elemtypee);//插入操作 ListDelete(SqList&L,inti,Elemtypee);//删除操作 LocateElem(SqList&L,Elemtypee);//按值查找 GetElem(SqList&...
实现printf可变的域宽度
07-31 136
printf参数汇总
honpey爱编程
06-28 699
文章来源：printf 参数汇总 格式描述串"是由一系列的"格式转换说明符号"组成,格式转换说明符号的描述形式如下: % [+][-] 0 m[.n] [输出精度] (1)形式字母:制定输出格式,如表 d:十进制整型数 i:十进制整型数 x:十六进制整型数 o:八进制整型数 u:无符号十进制整型数 c:单个字符; s:字符串 e:指数形式的浮点数 f:小数形式的浮点数
cpp学习笔记：STL list容器
ohhjack的博客
11-18 565
cpp
C++可变参数的实现方法
12-31
可变参数的实现要解决三个问题: 1.如何调用带有可变参数的函数2.如何编译有可变参数的程序3.在带有可变参数的函数体中如何持有可变参数第一个问题, 调用时在可以传入可变参数的地方传入可变参数即可，当然，还有一些...
C51可变参数讲解.pdf
07-15
keil C51可变参数讲解，自定义允许访问可变长度参数列表的函数。
C语言可变参数及printf函数的实现
04-15
C语言 可变参数及printf函数的实现
printf可变参数实现
02-10
printf实现的代码，主要包括可变参数的功能实现。
数据结构基础代码3：在顺序表L的第i位置插入新元素e
xiuhhhua的博客
07-31 4168
本次的代码主要思路就是通过指针传入线性表（为何使用指针详情见后续更新或通过百度），传入position，value值，将线性表内的position后的数值依次向后移动，直到将position的位置的元素复制到position+1的位置，后为position赋值value。代码块中的printflist（）函数仅仅是为了方便输出，多次调用减少代码量写的。重点是要将线性表的length+1！...
C++--格式输出细节
dingdi3021的博客
06-12 114
2014-06-1200:06:41 C++文件读入读出： 　　（1）ifstream(fname) 建立读入流，如：ifstream fin("in.txt") 　　（2）ostream(fname) 建立读出流 　　（3）getline(istream &is , string &str , char delim ) 行读入，以delim字符为结尾，缺省为'...
可变参数列表(模拟实现printf)
congjichukaishi的博客
05-23 212
1.什么是可变参数列表？通过将函数实现为可变参数的形式，可以使得函数可以接受1个以上的任意多个参数。我们先看一个例子：   int average(int n,...) { va_list arg; //相当于声明一个指针，名字为arg int i = 0; int sum = 0; va_start(arg,n); for(i=0; i...
【C语言】用可变参数列表实现printf函数
zjy900507的博客
07-06 454
//用可变参数列表实现printf函数#include &lt;stdio.h&gt;#include &lt;stdarg.h&gt;void my_printf(const char *str,...){ va_list fun; va_start (fun,str); while(*str!=0) { if(*str=='c') { putchar(va_arg(fun,char )...
如何用printf实现可变的域宽度？
liuzhixin96的博客
06-02 454
如何用printf实现可变的域宽度 printf("%-2d \n",x); printf("%*d \n",width,x);
数据结构实现两个有序链表的合并（c语言）
热门推荐
七喜是雪碧
03-28 2万+
数据结构实现两个有序链表的合并（c语言） 现有两个有序单链表，通过代码实现将两个单链表合并为一个有序的新表，要求使用旧表的空间，不能新分配内存 #include <stdio.h> #include <stdlib.h> typedef struct List { int a; struct List *next; }list; void newList(list *l...
C语言简单链表详细步骤详解
weixin_51311708的博客
02-26 5072
+《链表——>小阿豪带你写链表》！！！！进入正文 1.首先，先想好自己要创建的链表格式以及最后的的显示界面！！！ 2.主函数尽量放到后面写，前面写功能函数，在调用主函数之前要声明一下！！ 3.先写链表主结构体，再写成员结构体，将成员结构体嵌入主结构体！！！ ~4.可以给你所需要的功能创建一个菜单，用switch-case语句实现功能！！！ 5.注意功能函数的放置次序，要不然会报错，必须声明！！！ 干货开始！！-》》》此处为伪代码内容 例： 0.先定义好你的成员结构...
数据结构笔记 四：顺序表
OnlyLove_的博客
10-12 535
一、定义 顺序表：用顺序存储的方式实现线性表。 顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间关系由存储单元的邻近关系来体现。 二、顺序表实现 1、静态分配 使用数组方式实现。 #define MAXSIZE 10 // 定义最大长度 typedef int ElemType; // 根据实际情况定义 typedef struct{ ElemType data[MAXSIZE]; // 用数组存放数据元素（ElemType -
C语言之利用可变参数列表实现简易的printf
Chenxi13
01-24 171
在最初接触C语言的时候就接触到 printf( ) 这个函数，当时并没有对此留心与研究，也没有发现这个函数跟其他普通函数存在区别，普通函数的参数在函数定义的时候就确定了，而 printf ( ) 函数的参数列表在调用时可以变化。所以再学习与了解可变参数列表以后，便利用可变参数列表实现了一个简易的 printf( ) 。 其代码如下：#define _CRT_SECURE_NO_WARNINGS
可变参数模板实现printf
最新发布
08-14
在C 11中，可以使用可变参数模板来实现类似printf函数的功能。下面是一个示例代码： ```cpp #include #include // 可变参数模板函数 template void myPrintf(const char* format, Args... args) { // 使用va_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值