c语言函数封装例子,c++函数封装和函数调用
使用C语言封装一个函数?
您好,对于你的遇到的问题,我很高兴能为你提供帮助,我之前也遇到过哟,以下是我的个人看法,希望能帮助到你,若有错误,还望见谅!。展开全部
创新互联长期为近千家客户提供的网站建设服务,团队从业经验10年,关注不同地域、不同群体,并针对不同对象提供差异化的产品和服务;打造开放共赢平台,与合作伙伴共同营造健康的互联网生态环境。为陆港企业提供专业的成都网站建设、做网站,陆港网站改版等技术服务。拥有十余年丰富建站经验和众多成功案例,为您定制开发。
用C语言的时候,您是否还在使用printf函数来输出日志呢?您是否考虑过将printf函数打印的内容存到文件中去呢?您是否想拥有一个可选择的既支持输出到屏幕又支持存储到文件中的日志函数呢?很高兴的告诉您,如果您愿意的话,欢迎使
一、定义宏变量BUF_SIZE
view plaincopy to clipboardprint?
#define BUF_SIZE 1024
二、定义log_st结构体
view plaincopy to clipboardprint?
typedef struct _log_st log_st;
struct _log_st
{
char path[128];
int fd;
int size; 非常感谢您的耐心观看,如有帮助请采纳,祝生活愉快!谢谢!
C语言怎么封装自己写的函数
用C语言的时候,您是否还在使用printf函数来输出日志呢?您是否考虑过将printf函数打印的内容存到文件中去呢?您是否想拥有一个可选择的既支持输出到屏幕又支持存储到文件中的日志函数呢?很高兴的告诉您,如果您愿意的话,欢迎使用本人编写的一个一套日志函数,该套函数由五部分组成,分别是宏变量BUF_SIZE、结构体log_st、log_init函数、log_debug函数和log_checksize函数。其中宏变量BUF_SIZE用来限制每次输出的日志的最大长度;结构体用来存储用户需求,包括文件路径、文件描述符号、单个文件最大大小、输出方式标志、文件命名标志等;log_init函数用来完成用户需求录入、文件创建等功能,在mian函数的开始调用一次即可;log_debug函数的功能跟printf很类似,是在printf基础上进行的扩充,实现将日志输出到屏幕或者写入到文件,在需要打印日志的地方调用该函数;log_checksize函数用来检测日志文件大小是否超过最大大小限制,它需要您定时或者定点调用它,如果一直不调用,则日志文件将不受指定的最大大小限制。
一、定义宏变量BUF_SIZE
view plaincopy to clipboardprint?
#define BUF_SIZE 1024
二、定义log_st结构体
view plaincopy to clipboardprint?
typedef struct _log_st log_st;
struct _log_st
{
char path[128];
int fd;
int size;
int level;
int num;
};
三、定义log_init函数
参数说明:path——您要存储的文件路径;size——单个文件的最大大小,如果超过该大小则新建新的文件用来存储;level——日志输出方式,建议在上层限制其值的范围为0到3,0表示日志既不输出到屏幕也不创建文件和保存到文件,1表示日志保存到文件但不输出到屏幕,2表示日志既输出到屏幕也保存到文件,3表示日志只输出到文件而不创建文件和存入文件;num——日志文件命名方式,非0表示以(int)time(NULL)作为文件名来保存文件,文件数量随着日志量的递增而递增;0表示以“.new”和“.bak”为文件名来保存文件,文件数量不超过两个,随着日志量的递增,旧的日志文件将被新的覆盖,更直观的说就是说.new”和“.bak”文件只保存最近的日志。
view plaincopy to clipboardprint?
log_st *log_init(char *path, int size, int level, int num)
{
char new_path[128] = {0};
if (NULL == path || 0 == level) return NULL;
log_st *log = (log_st *)malloc(sizeof(log_st));
memset(log, 0, sizeof(log_st));
if (level != 3)
{
//the num use to control file naming
log-num = num;
if(num)
snprintf(new_path, 128, "%s%d", path, (int)time(NULL));
else
snprintf(new_path, 128, "%s.new", path);
if(-1 == (log-fd = open(new_path, O_RDWR|O_APPEND|O_CREAT|O_SYNC, S_IRUSR|S_IWUSR|S_IROTH)))
{
free(log);
log = NULL;
return NULL;
}
}
strncpy(log-path, path, 128);
log-size = (size 0 ? size:0);
log-level = (level 0 ? level:0);
return log;
}
四、定义log_debug函数
view plaincopy to clipboardprint?
void log_debug(log_st *log, const char *msg, ...)
{
va_list ap;
time_t now;
char *pos;
char _n = '\n';
char message[BUF_SIZE] = {0};
int nMessageLen = 0;
int sz;
if(NULL == log || 0 == log-level) return;
now = time(NULL);
pos = ctime(now);
sz = strlen(pos);
pos[sz-1]=']';
snprintf(message, BUF_SIZE, "[%s ", pos);
for (pos = message; *pos; pos++);
sz = pos - message;
va_start(ap, msg);
nMessageLen = vsnprintf(pos, BUF_SIZE - sz, msg, ap);
va_end(ap);
if (nMessageLen = 0) return;
if (3 == log-level)
{
printf("%s\n", message);
return;
}
if (2 == log-level)
printf("%s\n", message);
write(log-fd, message, strlen(message));
write(log-fd, _n, 1);
fsync(log-fd);
}
五、定义log_checksize函数
view plaincopy to clipboardprint?
void log_checksize(log_st *log)
{
struct stat stat_buf;
char new_path[128] = {0};
char bak_path[128] = {0};
if(NULL == log || 3 == log-level || '\0' == log-path[0]) return;
memset(stat_buf, 0, sizeof(struct stat));
fstat(log-fd, stat_buf);
if(stat_buf.st_size log-size)
{
close(log-fd);
if(log-num)
snprintf(new_path, 128, "%s%d", log-path, (int)time(NULL));
else
{
snprintf(bak_path, 128, "%s.bak", log-path);
snprintf(new_path, 128, "%s.new", log-path);
remove(bak_path); //delete the file *.bak first
rename(new_path, bak_path); //change the name of the file *.new to *.bak
}
//create a new file
log-fd = open(new_path, O_RDWR|O_APPEND|O_CREAT|O_SYNC, S_IRUSR|S_IWUSR|S_IROTH);
}
}
C语言如何封装printf函数
你输入6后回车,程序先读入6,不是回车,输出6,然后读入回车结束循环,在输出yes,所以结果是6yes。
注意:while循环就只有一个语句:printf("%c",c);
printf("yes");语句是在while循环外的,所以只要while循环结束就会输出yes。
printf这样参数可变的函数如何封装
C中的可变参数研究
一. 何谓可变参数
int printf( const char* format, ...);
这是使用过C语言的人所再熟悉不过的printf函数原型,它的参数中就有固定参数format和可变参数(用”…”表示). 而我们又可以用各种方式来调用printf,如:
printf("%d",value);
printf("%s",str);
printf("the number is %d ,string is:%s", value, str);
二.实现原理
C语言用宏来处理这些可变参数。这些宏看起来很复杂,其实原理挺简单,就是根据参数入栈的特点从最靠近第一个可变参数的固定参数开始,依次获取每个可变参数的地址。下面我们来分析这些宏。在VC中的stdarg.h头文件中,针对不同平台有不同的宏定义,我们选取X86平台下的宏定义:
typedef char *va_list;
/*把va_list被定义成char*,这是因为在我们目前所用的PC机上,字符指针类型可以用来存储内存单元地址。而在有的机器上va_list是被定义成void*的*/
#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) ~(sizeof(int) - 1) )
/*_INTSIZEOF(n)宏是为了考虑那些内存地址需要对齐的系统,从宏的名字来应该是跟sizeof(int)对齐。一般的sizeof(int)=4,也就是参数在内存中的地址都为4的倍数。比如,如果sizeof(n)在1-4之间,那么_INTSIZEOF(n)=4;如果sizeof(n)在5-8之间,那么_INTSIZEOF(n)=8。*/
#define va_start(ap,v)( ap = (va_list)v + _INTSIZEOF(v) )
/*va_start的定义为 v+_INTSIZEOF(v) ,这里v是最后一个固定参数的起始地址,再加上其实际占用大小后,就得到了第一个可变参数的起始内存地址。所以我们运行va_start(ap, v)以后,ap指向第一个可变参数在的内存地址*/
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
/*这个宏做了两个事情,
①用用户输入的类型名对参数地址进行强制类型转换,得到用户所需要的值
②计算出本参数的实际大小,将指针调到本参数的结尾,也就是下一个参数的首地址,以便后续处理。*/
#define va_end(ap) ( ap = (va_list)0 )
/*x86平台定义为ap=(char*)0;使ap不再 指向堆栈,而是跟NULL一样.有些直接定义为((void*)0),这样编译器不会为va_end产生代码,例如gcc在linux的x86平台就是这样定义的. 在这里大家要注意一个问题:由于参数的地址用于va_start宏,所以参数不能声明为寄存器变量或作为函数或数组类型. */
以下再用图来表示:
在VC等绝大多数C编译器中,默认情况下,参数进栈的顺序是由右向左的,因此,参数进栈以后的内存模型如下图所示:最后一个固定参数的地址位于第一个可变参数之下,并且是连续存储的。
|——————————————————————————|
|最后一个可变参数 | -高内存地址处
|——————————————————————————|
...................
|——————————————————————————|
|第N个可变参数 | -va_arg(arg_ptr,int)后arg_ptr所指的地方,
| | 即第N个可变参数的地址。
|——————————————— |
………………………….
|——————————————————————————|
|第一个可变参数 | -va_start(arg_ptr,start)后arg_ptr所指的地方
| | 即第一个可变参数的地址
|——————————————— |
|———————————————————————— ——|
| |
|最后一个固定参数 | - start的起始地址
|—————————————— —| .................
|—————————————————————————— |
| |
|——————————————— |- 低内存地址处
三.printf研究
下面是一个简单的printf函数的实现,参考了中的156页的例子,读者可以结合书上的代码与本文参照。
#include "stdio.h"
#include "stdlib.h"
void myprintf(char* fmt, ...) //一个简单的类似于printf的实现,//参数必须都是int 类型
{
char* pArg=NULL; //等价于原来的va_list
char c;
pArg = (char*) fmt; //注意不要写成p = fmt !!因为这里要对//参数取址,而不是取值
pArg += sizeof(fmt); //等价于原来的va_start
do
{
c =*fmt;
if (c != '%')
{
putchar(c); //照原样输出字符
}
else
{
//按格式字符输出数据
switch(*++fmt)
{
case 'd':
printf("%d",*((int*)pArg));
break;
case 'x':
printf("%#x",*((int*)pArg));
break;
default:
break;
}
pArg += sizeof(int); //等价于原来的va_arg
}
++fmt;
}while (*fmt != '\0');
pArg = NULL; //等价于va_end
return;
}
int main(int argc, char* argv[])
{
int i = 1234;
int j = 5678;
myprintf("the first test:i=%d",i,j);
myprintf("the secend test:i=%d; %x;j=%d;",i,0xabcd,j);
system("pause");
return 0;
}
在intel+win2k+vc6的机器执行结果如下:
the first test:i=1234
the secend test:i=1234; 0xabcd;j=5678;
四.应用
求最大值:
#include //不定数目参数需要的宏
int max(int n,int num,...)
{
va_list x;//说明变量x
va_start(x,num);//x被初始化为指向num后的第一个参数
int m=num;
for(int i=1;i {
//将变量x所指向的int类型的值赋给y,同时使x指向下一个参数
int y=va_arg(x,int);
if(ym)m=y;
}
va_end(x);//清除变量x
return m;
}
main()
{
printf("%d,%d",max(3,5,56),max(6,0,4,32,45,533));
}
c语言中要封装一个函数( 比如什么printf之类的),肯定得用.c和.h文件,函数声明在.h文件中.函数实现在c文
//mvector.h -- 声明
#ifndef MVECTOR_H_
#define MVECTOR_H_
typedef struct _mvect
{
int x;
int y;
}vect;
void getvect(vect* v);//声明
void showvect(vect v);//声明
#endif
//mvector.c -- 实现
#include "mvector.h"
#include stdio.h
void getvect(vect* v)
{
scanf("%d,%d",(v-x),(v-y));
}
void showvect(vect v)
{
printf("%d,%d",v.x,v.y);
}
//main.c -- 使用
#include "mvector.h"
#include stdio.h
int main()
{
vect a;
getvect(a);
showvect(a);
}
注意mvector.h必须位于当前文件夹下,且必须把mvector.c和main.c放在一个工程里编译。
输入:2,3
输出:2,3
如何用C语言封装 C++的类,在 C里面使用
C一般不能直接调用C++函数库,需要将C++库封装成C接口后,才可以使用C调用。
下面举例,说明一个封装策略:
//code in add.cxx
#include "add.h"
int sample::method()
{
cout"method is called!\n";
}
//code in add.h
#include
using namespace std;
class sample
{
public:
int method();
};
将上面的两个文件生成动态库libadd.so放到 /usr/lib目录下,编译命令如下:
sudo g++ -fpic -shared -g -o /usr/lib/libadd.so add.cxx -I ./
由于在C中不能识别类,所以要将上面类的成员函数,要封装成C接口函数才能被调用。下面进行封装,将输出接口转换成C接口。
//code in mylib.cxx
#include "add.h"
#ifndef _cplusplus
#define _cplusplus
#include "mylib.h"
#endif
int myfunc()
{
sample ss;
ss.method();
return 0;
}
//code in mylib.h
#ifdef _cplusplus
extern "C"
{
#endif
int myfunc();
#ifdef _cplusplus
}
#endif
在linux下,gcc编译器并没用变量_cplusplus来区分是C代码还是C++ 代码(没有宏定义),如果使用gcc编译器,这里我们可以自己定义一个变量_cplusplus用于区分C和C++代码,所以在mylib.cxx中定义 了一个变量_cplusplus用于识别是否需要“extern "C"”将函数接口封装成C接口。但是如果使用g++编译器则不需要专门定义_cplusplus,编译命令如下:
g++ -fpic -shared -g -o mylib.so mylib.cxx -la -I ./
main.c
#include
#include
#include "mylib.h"
int
main()
{
int (*dlfunc)();
void *handle; //定义一个句柄
handle = dlopen("./mylib.so", RTLD_LAZY);//获得库句柄
dlfunc = dlsym(handle, "myfunc"); //获得函数入口
(*dlfunc)();
dlclose(handle);
return 0;
}
编译命令如下:
gcc -o main main.c ./mylib.so -ldl
下面就可以执行了。
需要说明的是,由于main.c 和 mylib.cxx都需要包含mylib.h,并且要将函数myfunc封装成C接口函数输出需要“extern "C"”,而C又不识别“extern "C"”,所以需要定义_cplusplus来区别处理mylib.h中的函数myfunc。
在main.c的main函数中直接调用myfunc()函数也能执行,这里介绍的是常规调用库函数的方法。
网页名称:c语言函数封装例子,c++函数封装和函数调用
网站网址:http://ybzwz.com/article/phdgcd.html