一、说明
在Linux C的实际编程应用中，有很多有用的实践技巧，编程中掌握这些知识，会对编程有事半功倍的效果。
二、常用技巧
2.1 if 变量条件的写法
main.c：
#include <stdio.h>
int main(int argc, char *argv[])
{
int a = 0;
if (a == 5) {
printf("hello world\n");
}
return 0;
}
if (a == 5)是正常写法， 但有时编程人员会误写为if (a =5),而a=5是一个合法的赋值表达式，并且a=5这个表达式的值也是5，这样if条件就为真，打印出hello world,如下：
main.c:
#include <stdio.h>
int main(int argc, char *argv[])
{
int a = 0;
printf("before a:%d\n", a);
if (a = 5) {
printf("hello world\n");
}
printf("after a:%d\n", a);
return 0;
}
测试结果：
$ ./a.out
before a:0
hello world
after a:5
为了避免上述问题，一般将值放在左面，变量放在右面，如果编程时不小心少写了一个“=”时，在编译阶段就会报语法错误，避免在运行时发生的逻辑错误。如下：
main.c:
#include <stdio.h>
int main(int argc, char *argv[])
{
int a = 0;
printf("before a:%d\n", a);
if (5 == a) {
printf("hello world\n");
}
return 0;
}
如果编程人员误写成a=5时，编译时报如下错误，这样就可以在编译时发现错误，从而避免在程序运行时发生让人难以定位的逻辑错误。
$ gcc main.c
main.c: In function ‘main’:
main.c:9:11: error: lvalue required as left operand of assignment
if (5 = a) {
^
注：以上问题不仅是初级程序员最容易犯的错误，高级程序员也经常犯，因此写成if (5 == a)的形式，是一种非常好的编程习惯。
2.2 strncmp的使用
strncmp是编程中非常常用的函数，但该函数存在一些陷阱，如下分析：
int strncmp(const char *s1, const char *s2, size_t n);
strncmp函数用来对比前n个字节，n的长度影响比较的结果。在对比两个字符串是否完全相等时，有以下三种用法：
1.n使用s1的长度
2.n使用s2的长度
3.n使用s1和s2的最大长度
如下strncmp_test1、strncmp_test2和strncmp_test3的代码
main.c：
#include <stdio.h>
#include <string.h>
int strncmp_test1(char *str_a, char *str_b)
{
int str_a_len = 0;
int str_b_len = 0;
int ret = 0;
str_a_len = strlen(str_a);
str_b_len = strlen(str_b);
printf("%s: str_a: [%s], str_b: [%s]\n", __FUNCTION__, str_a, str_b);
ret = strncmp(str_a, str_b, str_a_len);
if (0 == ret) {
printf("%s: [%s] == [%s]\n", __FUNCTION__, str_a, str_b);
} else if (ret < 0) {
printf("%s: [%s] < [%s]\n", __FUNCTION__, str_a, str_b);
} else {
printf("%s: [%s] > [%s]\n", __FUNCTION__, str_a, str_b);
}
return 0;
}
int strncmp_test2(char *str_a, char *str_b)
{
int str_a_len = 0;
int str_b_len = 0;
int ret = 0;
str_a_len = strlen(str_a);
str_b_len = strlen(str_b);
printf("%s: str_a: [%s], str_b: [%s]\n", __FUNCTION__, str_a, str_b);
ret = strncmp(str_a, str_b, str_b_len);
if (0 == ret) {
printf("%s: [%s] == [%s]\n", __FUNCTION__, str_a, str_b);
} else if (ret < 0) {
printf("%s: [%s] < [%s]\n", __FUNCTION__, str_a, str_b);
} else {
printf("%s: [%s] > [%s]\n", __FUNCTION__, str_a, str_b);
}
return 0;
}
int strncmp_test3(char *str_a, char *str_b)
{
int str_a_len = 0;
int str_b_len = 0;
int ret = 0;
int cmp_len = 0;
str_a_len = strlen(str_a);
str_b_len = strlen(str_b);
printf("%s: str_a: [%s], str_b: [%s]\n", __FUNCTION__, str_a, str_b);
cmp_len = str_a_len > str_b_len ? str_a_len : str_b_len;
ret = strncmp(str_a, str_b, cmp_len);
if (0 == ret) {
printf("%s: [%s] == [%s]\n", __FUNCTION__, str_a, str_b);
} else if (ret < 0) {
printf("%s: [%s] < [%s]\n", __FUNCTION__, str_a, str_b);
} else {
printf("%s: [%s] > [%s]\n", __FUNCTION__, str_a, str_b);
}
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 3) {
printf("usage: ./a.out <str_a> <str_b>\n");
return -1;
}
strncmp_test1(argv[1], argv[2]);
strncmp_test2(argv[1], argv[2]);
strncmp_test3(argv[1], argv[2]);
return 0;
}
测试结果：
$ ./a.out hello hello2
strncmp_test1: str_a: [hello], str_b: [hello2]
strncmp_test1: [hello] == [hello2]
strncmp_test2: str_a: [hello], str_b: [hello2]
strncmp_test2: [hello] < [hello2]
strncmp_test3: str_a: [hello], str_b: [hello2]
strncmp_test3: [hello] < [hello2]
$ ./a.out hello2 hello
strncmp_test1: str_a: [hello2], str_b: [hello]
strncmp_test1: [hello2] > [hello]
strncmp_test2: str_a: [hello2], str_b: [hello]
strncmp_test2: [hello2] == [hello]
strncmp_test3: str_a: [hello2], str_b: [hello]
strncmp_test3: [hello2] > [hello]
2.3 goto的使用
goto关键字是用来做程序跳转使用的，编程书中一般都不推荐使用goto,但在实际的编程应用中确是很常见，一般有以下几种情况使用：
1.函数执行过程中，某一行代码出现逻辑错误，跳转到函数尾部，进行资源清理
2.函数执行过程中，满足预期条件时，跳过部分代码，继续执行
函数执行过程中，满足预期条件时，跳回到前面代码，继续执行
2.4 sizeof与strlen
sizeof与strlen在编程中很常用，也是犯错误比较多的地方，必须要熟练掌握
2.4.1 strlen
#include <string.h>
size_t strlen(const char *s);
strlen()函数返回字符串的长度（字节数），有两点要注意
1.字符串必须以’\0’结尾
2.参数不能是空指针，否则出现crash
2.4.2 sizeof
sizeof是运算符，可以计算出变量类型占的存储空间，以数组名作参数时，可以计算整个数组的大小。
面试中常有的一道题目：给定一个数组名Array，计算数组的长度。可以使用sizeof(array) / sizeof(array[0])计算出数组的长度
2.5 printf的使用
printf()是c语言中打印调试信息的函数，是程序调试、问题定位分析最基础的手段，对于不同类型变量的打印，需要使用不同的格式参数，也是初级程序员最容易犯错误的地方。
format-output.c：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char *str = "hello world";
int value = 101;
long data = 0x1234;
char buf[64] = {0};
printf("str: %s, \n", str);
printf("str: %.*s, \n", 5, str);
printf("str: %s, value:%d\n", str, value);
printf("data: %ld\n", data);
printf("data: 0x%lx\n", data);
printf("data: 0x%lx\n", data & 0xff);
printf("data: 0x%lx\n", (data & 0xff00) >> 8);
snprintf(buf, sizeof(buf), "str: %s, value: %d", str, value);
printf("buf:%s\n", buf);
return 0;
}
2.6 结构体中的0字节长度数组
0字节长度的数据主要用于网络消息（二进制消息）协议中，用于表示变长的负载数据。如下示例中的com_msg_s结构体中的data数组。
common.h :
#ifndef __COMMON_H__
#define __COMMON_H__
typedef struct com_msg_s {
int seq;
long timestamp;
int data_len;
char data[0];
} com_msg_t;
client_tcp.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <errno.h>
#include "common.h"
#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 9999
typedef int (*client_callback_t)(int fd, struct epoll_event *event);
enum epoll_cb_id_e {
EPOLL_CB_ID_USER_INPUT,
EPOLL_CB_ID_SERVER,
EPOLL_CB_ID_MAX,
};
int g_running = 1;
int g_epoll_fd = -1;
int g_server_socket_fd = -1;
int g_seq = 0;
int client_tcp_connect(char *server_ip, int server_port)
{
int ret = 0;
long socket_fd = -1;
int addr_len = 0;
struct epoll_event event;
struct sockaddr_in server_addr;
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if (socket_fd < 0) {
printf("%s: socket failed\n", __FUNCTION__);
return 0;
}
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(server_port);
server_addr.sin_addr.s_addr = inet_addr(server_ip);
addr_len = sizeof(server_addr);
ret = connect(socket_fd, (struct sockaddr *)&server_addr, addr_len);
if (ret < 0) {
printf("%s: connect failed\n", __FUNCTION__);
goto on_error;
}
event.events = EPOLLIN;
event.data.u64 = socket_fd << 32 | EPOLL_CB_ID_SERVER;
ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, socket_fd, &event);
if(ret < 0) {
printf("epoll_ctl failure:%s\n", strerror(errno));
close(g_epoll_fd);
return -1;
}
return socket_fd;
on_error:
close(socket_fd);
return -1;
}
int client_user_input_listen()
{
int ret = 0;
long fd = STDIN_FILENO;
struct epoll_event event;
event.events = EPOLLIN;
event.data.u64 = fd << 32 | EPOLL_CB_ID_USER_INPUT;
ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, fd, &event);
if(ret < 0) {
printf("epoll_ctl failure:%s\n", strerror(errno));
return -1;
}
return 0;
}
int client_send_msg(int socket_fd, char *data, int len)
{
int ret = 0;
char buf[1024] = {0};
int msg_len = 0;
com_msg_t *com_msg = NULL;
com_msg = (com_msg_t *)buf;
com_msg->seq = g_seq++;
com_msg->timestamp = time(NULL);
com_msg->data_len = len;
memcpy(com_msg->data, data, len);
msg_len = sizeof(com_msg_t) + len;
printf(">>> send request len[%d] data[%.*s] seq[%d] to server fd[%d]\n",
com_msg->data_len,
com_msg->data_len, com_msg->data,
com_msg->seq,
socket_fd);
ret = write(socket_fd, buf, msg_len);
return 0;
}
int server_msg_process(int server_fd, char *msg_buf, int msg_len)
{
com_msg_t *com_msg = NULL;
com_msg = (com_msg_t *)msg_buf;
printf("<<< recv response len[%d] data[%.*s] seq[%d] from server fd[%d]\n",
com_msg->data_len,
com_msg->data_len, com_msg->data, com_msg->seq, server_fd);
return 0;
}
int client_callback_server(int fd, struct epoll_event *event)
{
char buf[1024] = {0};
int read_len = 0;
if(event->events == EPOLLIN) {
read_len = read(fd, buf, 1024);
if (read_len > 0) {
server_msg_process(fd, buf, read_len);
} else if (read_len < 0) {
epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, fd, NULL);
close(fd);
} else if (0 == read_len) {
printf("client fd[%d] disconnect from server\n", fd);
g_running = 0;
epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, fd, NULL);
close(fd);
}
}
return 0;
}
int client_input_process(char *buf, int len)
{
printf("----user input: %s\n", buf);
if (0 == strncmp(buf, "exit", strlen("exit"))) {
g_running = 0;
return 0;
}
client_send_msg(g_server_socket_fd, buf, len);
return 0;
}
int client_callback_user_input(int fd, struct epoll_event *event)
{
char buf[1024] = {0};
int read_len = 0;
if(event->events == EPOLLIN) {
read_len = read(fd, buf, 1024);
if (read_len > 0) {
buf[read_len - 1] = '\0';
read_len -= 1;
client_input_process(buf, read_len);
} else if (read_len < 0) {
epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, fd, NULL);
close(fd);
} else if (0 == read_len) {
printf("%s: client fd[%d] disconnect\n", __FUNCTION__, fd);
epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, fd, NULL);
close(fd);
}
}
return 0;
}
client_callback_t g_client_callback[EPOLL_CB_ID_MAX] = {
&client_callback_user_input,
&client_callback_server,
};
int client_epoll_event_process(struct epoll_event *event)
{
int cb_id = -1;
int fd = -1;
cb_id = event->data.u64 & 0xffff;
fd = event->data.u64 >> 32;
if (fd < 0) {
printf("%s: invalid fd[%d]\n", __FUNCTION__, fd);
return -1;
}
if (cb_id < 0 || cb_id >= EPOLL_CB_ID_MAX) {
printf("%s: invalid cb id[%d]\n", __FUNCTION__, cb_id);
return -1;
}
//printf("cb id:%d, fd:%d\n", cb_id, fd);
(g_client_callback[cb_id])(fd, event);
return 0;
}
int main(int argc, char *argv[])
{
int ret = 0;
int num = 0;
int i = 0;
struct epoll_event events_array[10];
if (argc < 3) {
printf("usage: %s 127.0.0.1 9999\n", argv[0]);
return -1;
}
g_epoll_fd = epoll_create(10);
if (g_epoll_fd < 0) {
printf("epoll_create failure:%s\n", strerror(errno));
return -1;
}
g_server_socket_fd = client_tcp_connect(argv[1], atoi(argv[2]));
if (g_server_socket_fd < 0) {
printf("%s: tcp connect failed\n", __FUNCTION__);
return -1;
}
client_user_input_listen();
while (g_running) {
num = epoll_wait(g_epoll_fd, events_array, 10, -1);
if (num < 0) {
printf("epoll_wait failure:%s\n", strerror(errno));
close(g_epoll_fd);
break;
} else if (num == 0) {
printf("eopll_wait timeout!\n");
continue;
}
for (i = 0; i < num; i++) {
client_epoll_event_process(&events_array[i]);
}
}
printf("client exit\n");
close(g_server_socket_fd);
return 0;
}
server_tcp.c:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <errno.h>
#include "common.h"
#define SERVER_PORT 9999
typedef int (*server_callback_t)(int fd, struct epoll_event *event);
enum epoll_cb_id_e {
EPOLL_CB_ID_LISTEN,
EPOLL_CB_ID_CLIENT,
EPOLL_CB_ID_MAX,
};
int g_epoll_fd = -1;
int server_tcp()
{
int ret = 0;
long socket_fd = -1;
int addr_len = 0;
unsigned int value = 1;
struct epoll_event event;
struct sockaddr_in server_addr;
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if (socket_fd < 0) {
printf("%s: socket failed\n", __FUNCTION__);
goto on_error;
}
if (setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR,
(void *)&value, sizeof(value)) < 0) {
printf("%s: Fail to setsockopt\n", __FUNCTION__);
goto on_error;
}
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVER_PORT);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr_len = sizeof(server_addr);
ret = bind(socket_fd, (const struct sockaddr *)&server_addr, addr_len);
if (ret < 0) {
printf("%s: bind failed\n", __FUNCTION__);
goto on_error;
}
ret = listen(socket_fd, 5);
if (ret < 0) {
printf("%s: listen failed\n", __FUNCTION__);
goto on_error;
}
event.events = EPOLLIN;
event.data.u64 = socket_fd << 32 | EPOLL_CB_ID_LISTEN;
ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, socket_fd, &event);
if(ret < 0) {
printf("epoll_ctl failure:%s\n", strerror(errno));
close(g_epoll_fd);
return -1;
}
return 0;
on_error:
close(socket_fd);
return -1;
}
int server_callback_listen(int fd, struct epoll_event *in_event)
{
int ret = -1;
long client_fd = -1;
int addr_len = 0;
struct epoll_event event;
struct sockaddr_in client_addr;
memset(&client_addr, 0, sizeof(client_addr));
addr_len = sizeof(client_addr);
if(in_event->events == EPOLLIN) {
client_fd = accept(fd, (struct sockaddr *)&client_addr, &addr_len);
if (client_fd < 0) {
printf("%s: invalid client fd[%ld]\n", __FUNCTION__, client_fd);
return -1;
}
printf("client %s:%d fd[%ld] connect\n",
inet_ntoa(client_addr.sin_addr),
ntohs(client_addr.sin_port), client_fd);
event.events = EPOLLIN;
event.data.u64 = client_fd << 32 | EPOLL_CB_ID_CLIENT;
ret = epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, client_fd, &event);
if(ret < 0) {
printf("epoll_ctl failure:%s\n", strerror(errno));
return -1;
}
}
return 0;
}
int client_msg_process(int client_fd, char *msg_buf, int msg_len)
{
com_msg_t *com_msg = NULL;
com_msg = (com_msg_t *)msg_buf;
printf("<<< recv msg len[%d]\n", msg_len);
printf("<<< recv request len[%d] [%.*s] seq[%d] from client fd[%d] timestamp[%ld]\n",
com_msg->data_len,
com_msg->data_len, com_msg->data,
com_msg->seq,
client_fd,
com_msg->timestamp);
write(client_fd, msg_buf, msg_len);
printf(">>> send response len[%d] [%.*s] seq[%d] to client fd[%d]\n",
com_msg->data_len,
com_msg->data_len, com_msg->data,
com_msg->seq,
client_fd);
return 0;
}
int server_callback_client(int fd, struct epoll_event *event)
{
char buf[1024] = {0};
int read_len = 0;
if(event->events == EPOLLIN) {
read_len = read(fd, buf, 1024);
if (read_len > 0) {
client_msg_process(fd, buf, read_len);
} else if (read_len < 0) {
epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, fd, NULL);
close(fd);
} else if (0 == read_len) {
printf("client fd[%d] disconnect\n", fd);
epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, fd, NULL);
close(fd);
}
}
return 0;
}
server_callback_t g_server_callback[EPOLL_CB_ID_MAX] = {
&server_callback_listen,
&server_callback_client,
};
int epoll_event_process(struct epoll_event *event)
{
int cb_id = -1;
int fd = -1;
cb_id = event->data.u64 & 0xffff;
fd = event->data.u64 >> 32;
if (fd < 0) {
printf("%s: invalid fd[%d]\n", __FUNCTION__, fd);
return -1;
}
if (cb_id < 0 || cb_id >= EPOLL_CB_ID_MAX) {
printf("%s: invalid cb id[%d]\n", __FUNCTION__, cb_id);
return -1;
}
//printf("cb id:%d, fd:%d\n", cb_id, fd);
(g_server_callback[cb_id])(fd, event);
return 0;
}
int main(int argc, char *argv[])
{
int ret = -1;
int num = 0;
int i = 0;
struct epoll_event events_array[10];
g_epoll_fd = epoll_create(10);
if (g_epoll_fd < 0) {
printf("epoll_create failure:%s\n", strerror(errno));
return -1;
}
ret = server_tcp();
if (ret < 0) {
printf("%s: server tcp failed\n", __FUNCTION__);
return -1;
}
while (1) {
num = epoll_wait(g_epoll_fd, events_array, 10, -1);
if (num < 0) {
printf("epoll_wait failure:%s\n", strerror(errno));
close(g_epoll_fd);
break;
} else if (num == 0) {
printf("eopll_wait timeout!\n");
continue;
}
for (i = 0; i < num; i++) {
epoll_event_process(&events_array[i]);
}
}
return 0;
}
Makefile:
all:
gcc -o server server_tcp.c
gcc -o client client_tcp.c
clean:
-@rm server client
测试结果：
$ ./client 127.0.0.1 9999
hello
----user input: hello
>>> send request len[5] data[hello] seq[0] to server fd[4]
<<< recv response len[5] data[hello] seq[0] from server fd[4]
good
----user input: good
>>> send request len[4] data[good] seq[1] to server fd[4]
<<< recv response len[4] data[good] seq[1] from server fd[4]
$ ./server
client 127.0.0.1:48576 fd[5] connect
<<< recv msg len[29]
<<< recv request len[5] [hello] seq[0] from client fd[5] timestamp[1670918351]
>>> send response len[5] [hello] seq[0] to client fd[5]
<<< recv msg len[28]
<<< recv request len[4] [good] seq[1] from client fd[5] timestamp[1670918355]
>>> send response len[4] [good] seq[1] to client fd[5]
2.7 隐藏结构体成员变量
隐藏结构体成员是C++等面向对象语言中的功能，防止用户修改一些内部成员变量，造成程序异常。在C语言中，
也可以实现类似功能。原理就是将结构体定义放在.c文件中，.h中只放操作变量的函数。这样其它模块就算包含了.h文件，也不能看到结构体定义。
obj_manager.c：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "obj_manager.h"
struct obj_s {
int id;
char name[64];
};
void *allocate_obj()
{
void *obj = NULL;
obj = (void *)malloc(sizeof(struct obj_s));
return obj;
}
void set_obj_id(obj_t *obj, int id)
{
printf("%s: set id:%d\n", __FUNCTION__, id);
obj->id = id;
}
void set_obj_name(obj_t *obj, char *name)
{
printf("%s: set name:%s\n", __FUNCTION__, name);
strcpy(obj->name, name);
}
int get_obj_id(obj_t *obj)
{
return obj->id;
}
char *get_obj_name(obj_t *obj)
{
return obj->name;
}
obj_manager.h：
#ifndef __OBJ_MANAGER_H__
#define __OBJ_MANAGER_H__
typedef struct obj_s obj_t;
void *allocate_obj();
void set_obj_id(obj_t *obj, int id);
void set_obj_name(obj_t *obj, char *name);
int get_obj_id(obj_t *obj);
char *get_obj_name(obj_t *obj);
#endif
main.c：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "obj_manager.h"
int main(int argc, char *argv[])
{
obj_t *obj = NULL;
int id = 0;
obj = allocate_obj();
if (!obj) {
printf("allocate obj failed\n");
return -1;
}
//obj->id = 1;
set_obj_id(obj, 1);
set_obj_name(obj, "zhangsan");
printf("get id:%d, name:%s\n", get_obj_id(obj), get_obj_name(obj));
return 0;
}
Makefile:
all:
gcc -o a.out main.c obj_manager.c
clean:
-@rm a.out
测试：
$ ./a.out
set_obj_id: set id:1
set_obj_name: set name:zhangsan
get id:1, name:zhangsan
这里需要像C++一样调用函数接口对变量赋值，如果直接对变量赋值，编译时会报错,如下
$ make
gcc -o a.out main.c obj_manager.c
main.c: In function ‘main’:
main.c:18:8: error: dereferencing pointer to incomplete type
obj->id = 1;
^
make: *** [all] Error 1
2.8 格式化时间打印
main.c
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
int test()
{
char time_buf[128] = {0};
struct timeval tv;
struct tm time_tm;
gettimeofday(&tv, NULL);
localtime_r(&tv.tv_sec, &time_tm);
snprintf(time_buf, sizeof(time_buf), "%d-%02d-%02d %02d:%02d:%02d.%03d",
time_tm.tm_year + 1900,
time_tm.tm_mon+1,
time_tm.tm_mday,
time_tm.tm_hour,
time_tm.tm_min,
time_tm.tm_sec,
(int)tv.tv_usec / 1000);
printf("%s\n", time_buf);
return 0;
}
int main(int argc, char *argv[])
{
int i = 0;
test();
return 0;
}
测试结果：
$ ./a.out
2022-12-13 16:04:06.471
$ ./a.out
2022-12-13 16:04:23.279
2.9 时间耗费调试
处理耗时是软件性能的一个重要指标，对于c程序，经常需要测试一段代码或一个函数的耗时，可以使用如下方式：
main.c
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>
int test1()
{
time_t start_time = 0;
time_t end_time = 0;
int diff = 0;
start_time = time(NULL);
/* do something */
sleep(2);
end_time = time(NULL);
diff = end_time - start_time;
printf("%s: diff: %d seconds\n", __FUNCTION__, diff);
return 0;
}
int test2()
{
struct timeval tv_start;
struct timeval tv_end;
long start_ms = 0;
long end_ms = 0;
int diff_ms = 0;
gettimeofday(&tv_start, NULL);
start_ms = tv_start.tv_sec * 1000 + tv_start.tv_usec / 1000;
/* do something */
usleep(20000); //20ms
gettimeofday(&tv_end, NULL);
end_ms = tv_end.tv_sec * 1000 + tv_end.tv_usec / 1000;
diff_ms = end_ms - start_ms;
printf("%s: diff: %d ms\n", __FUNCTION__, diff_ms);
return 0;
}
int main(int argc, char *argv[])
{
struct timeval tv;
gettimeofday(&tv, NULL);
test1();
test2();
return 0;
}
测试：
$ ./a.out
test1: diff: 2 seconds
test2: diff: 20 ms
524
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
