分配数组
int *x, *y;
x = malloc(50*sizeof(int));
if(!x) {
perror("malloc");
return 1;
}
y = calloc(50, sizeof(int));
if (!y) {
perror("calloc");
return 1;
}calloc会将所申请的内存全部填充0，malloc则不会。
调整内存分配的大小
#include <stdlib.h>
void* realloc(void* ptr, size_t size);
创建匿名内存映射
#include <sys/mman.h>
void * mmap(void* start, size_t length, int port, int flags, int fd, off_t offset);
int munmap(void* start, size_t length);void* p;
p = mmap(NULL, // 此处无关紧要
512*1024, // 512KB
PROT_READ | PROT_WRITE， // 可供读取和写入
MAP_ANONYMOUS | MAP_PRIVATE, // 匿名与私有
-1, // fd 忽略
0); // offset 忽略
if (p == MAP_FAILED)
perror("mmap")
else-- 第一个参数start设定为NULL，表示匿名映射的起始地址由内核自行决定，也可以指定非NULL的值，只要能够对齐页面，这样会导致移植性早到破坏。
-- 为了让映射可读可写，一般设定prot参数为PROT_READ | PROT_WRITE。
-- flags参数设定为MAP_ANONYMOUS | MAP_PRIVATE,
-- 当MAP_ANONYMOUS设定时，参数fd和offset会被忽略。
相比malloc之后再设置为memset，calloc会更加方便。
映射/dev/zero
void* p;
int fd;
// 打开/dev/zero以备读取和写入
fd = open("/dev/zero", O_RDWR);
if (fd < 0) {
perror("open");
return 1;
}
// /dev/zero 的【0， page size】映射
p = mmap(NULL, //此时无关紧要
getpagesize(), // 映射一个页面
PROT_READ | PROT_WRITE, // 可写可读
MAP_PRIVATE, // 私有映射
fd, // 映射 /dev/zero
0);
if (p == MAP_FAILED) {
perror("mmap");
if (close(fd))
perror("close");
return -1;
}
//关闭 /dev/zero
if (close(fd))
perror("close");
将字符串复制到堆栈
alloca()常用于临时复制一个字符串
//想要复制 "song"
char* dup;
dup = alloca(strlen(song)+1);
strcpy(dup, song);
//操作dup
return;#define _GNU_SOURCE
#include <string.h>
char* strdupa(const char* s);
char* strndupa(const char* s, size_t n);设定字节
#include <string.h>
void* memset(void* s, int c, size_t n);
比较字节
#include <string.h>
int memcmp(const void* s1, const void* s2, size_t n);此函数会比较s1与s2的前n个字节，如果相等，返回0，如果s1<s2,返回<0的值，如果s1>s2，则返回.>0的值。
移动字节
#include <string.h>
void* memmove(void* dst, const void* src, size_t n);将src的前n个字节复制到dst,并返回dst.memmove()可以安全处理重叠区域。
#include <string.h>
void* memcpy(void* dst, const void* src, size_t n);memcpy如同memmove，但是dst和src不可以重叠，如果重叠，则是未定义的。
#include <string.h>
void* memccpy(void* dst, const void* src, int c, size_t n);memccpy()函数的行为如同memcpy()，但是如果此函数在src的前n个字节中发现了字节c，则停止复制，此函数会返回一个指针，指向dst中的c（如果找不到c，则指向NULL）之后的下一个字节。
最后使用mempcpy()，将数据复制到连续的内存位置。
#define _GNU_SOURCE
#include <string.h>
void* mempcpy(void* dst, const void* src, size_t n);mempcpy()函数的执行如同memcpy()，但是它会返回一个指针，指向复制的最后一个字节的下一个字节，如果有一组数据想要复制到连续的内存位置，这会很有用。
搜素字节
#include <string.h>
void* memchr(const void* s, int c, size_t n);
#define _GNU_SOURCE
#include <string.h>
void* memrchr(const void* s, int c, size_t n);
旋转字节
#define _GNU_SOURCE
#include <string.h>
void* memfrob(void* s, size_t n);信号列表
等待任何一个信号
下面的程序会停在pause()处，直到收到一个信号，才会从pause()返回。
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
// SIGINT 处理程序
static void SIGINT_handler(int signo) {
printf("Caught SIGINT!\n");
exit(EXIT_SUCCESS);
}
int main(int argc, char** argv) {
/**
* 将SIGINT_handler注册为我们用于处理SIGINT的信号处理程序
*/
if (signal(SIGINT, SIGINT_handler) == SIG_ERR) {
fprintf(stderr, "Cannot handle SIGINT!\n");
exit(EXIT_FAILURE);
}
for(;;) {
pause();
}
return 0;
}
//编译：gcc -o test test.c
执行./test
然后输入Ctrl+C#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
// SIGINT 处理程序
static void SIGINT_handler(int signo) {
if (signo == SIGINT) {
printf("Caught SIGINT!\n");
} else if (signo == SIGTERM) {
printf("Caught SIGTERM!\n");
} else {
fprintf(stderr, "Unexpected signal!\n");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char** argv) {
/**
* 将SIGINT_handler注册为我们用于处理SIGINT的信号处理程序
*/
if (signal(SIGINT, SIGINT_handler) == SIG_ERR) {
fprintf(stderr, "Cannot handle SIGINT!\n");
exit(EXIT_FAILURE);
}
/**
* 将SIGINT_handler注册为我们用于处理SIGTERM的信号处理程序
*/
if (signal(SIGTERM, SIGINT_handler) == SIG_ERR) {
fprintf(stderr, "Cannot handle SIGTERM!\n");
exit(EXIT_FAILURE);
}
/**
* SIGPROF 的行为重置为默认值
*/
if (signal(SIGPROF, SIG_DFL) == SIG_ERR) {
fprintf(stderr, "Cannot handle SIGPROF!\n");
exit(EXIT_FAILURE);
}
/**
* 忽略SIGHUP
*/
if (signal(SIGHUP, SIG_IGN) == SIG_ERR) {
fprintf(stderr, "Cannot handle SIGHUP!\n");
exit(EXIT_FAILURE);
}
for(;;) {
pause();
}
return 0;
}发送一个信号
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int signo);
给自己发送一个信号
#include <signal.h>
int raise(int signo);给整个进程组传送一个信号
除了kill，可以使用
#include <signal.h>
int killpg(int pgrp, int signo);
等效于
kill (-pgrp, signo);保证可重入函数
信号集
#include <signal.h>
int sigemptyset(sigset_t * set);
int sigfillset(sigset_t* set);
int sigaddset(sigset_t* set, int signo);
int sigdelset(sigset_t* set, int signo);
int sigismember(const sigset_t* set, int signo);
linux还提供以下非标准的函数：
#define _GNU_SOURCE
#include <signal.h>
int sigisemptyset(sigset_t* set);
int sigorset(sigset_t * dest, sigset_t* left, sigset_t* right);
int sigandset(sigset_t* dest, sigset_t* left, sigset_t* right);时间的数据结构
#include <sys/time.h>
struct timeval {
time_t tv_sec; //seconds
susecondes_t tv_usec; //microsecondes
};
#include <time.h>
struct timespec {
time_t tv_sec; //seconds
long tv_nsec; //nanosecondes
};
获取当前时间
#include <time.h>
time_t time(time_t* t);
time_t t;
printf("current time: %ld\n", (long)time(&t));
printf("the same value: %ld\n", (long)t);
#include <sys/time.h>
int gettimeofday(struct timeval* tv, struct timezone* tz);
