linuxc的函数
把Signal(16, stop); 和Waiting(); 调换顺序试试，我现在没条件就不帮你试了
‘贰’ Linux C write函数
好隐蔽的一个错误！！ if ((fd=open(pathname, FLAGS, MODE)==-1)) 这句，括号的位置错误了
应该是： if ( (fd=open(pathname, FLAGS, MODE))==-1)
原写法，导致fd值为0，成了标准输入（终端）了，所以，lseek就会一直报错！
‘叁’ LinuxC语言头里面的ERROR函数怎么使用
errno会返回一个数字，每个数字代表一个错误类型。详细的可以查看头文件。/usr/include/asm/errno.h
如何把errno的数字转换成相应的文字说明？
方式一：可以使用strerrno函数
char
*strerror(int
errno)
使用方式如下：
fprintf(stderr,"error
in
CreateProcess
%s,
Process
ID
%d
",strerror(errno),processID)
将错误代码转换为字符串错误信息,可以将该字符串和其它的信息组合输出到用户界面。
注：假设processID是一个已经获取了的整形ID
方式二：使用perror函数
void
perror(const
char
*s)
函数说明
perror
(
)用来将上一个函数发生错误的原因输出到标准错误(stderr),参数s
所指的字符串会先打印出,后面再加上错误原因
字符串。此错误原因依照全局变量
errno
的值来决定要输出的字符串。
另外并不是所有的c函数调用发生的错误信息都会修改errno。例如gethostbyname函数。
errno是否是线程安全的？
errno是支持线程安全的，而且，一般而言，编译器会自动保证errno的安全性。
我们看下相关头文件
/usr/include/bits/errno.h
会看到如下内容：
#
if
!defined
_LIBC
||
defined
_LIBC_REENTRANT
/*
When
using
threads,
errno
is
a
per-thread
value.
*/
#
define
errno
(*__errno_location
())
#
endif
#
endif
/*
!__ASSEMBLER__
*/
#endif
/*
_ERRNO_H
*/
也就是说，在没有定义__LIBC或者定义_LIBC_REENTRANT的时候，errno是多线程/进程安全的。
为了检测一下你编译器是否定义上述变量，不妨使用下面一个简单程序。
#include
<stdio.h>
#include
<errno.h>
int
main(
void
)
{
#ifndef
__ASSEMBLER__
printf(
"Undefine
__ASSEMBLER__/n"
);
#else
printf(
"define
__ASSEMBLER__/n"
);
#endif
#ifndef
__LIBC
printf(
"Undefine
__LIBC/n"
);
#else
printf(
"define
__LIBC/n"
);
#endif
#ifndef
_LIBC_REENTRANT
printf(
"Undefine
_LIBC_REENTRANT/n"
);
#else
printf(
"define
_LIBC_REENTRANT/n"
);
#endif
return
0;
}
‘肆’ 红帽linux中C语言编程如何调用数学函数
红帽linux中C语言编程调用数学函数参考案例如下所示：
当需要调用函数的个数比较少时，可以直接在main函数中包含该文件，比如一个文件夹下包含add.c和main.c文件。
文件add.c定义两个整数相加的函数,code如下：#include
‘伍’ send的Linux C 函数
经套接字传送消息
相关函数
sendto,sendmsg,recv,recvfrom,recvmsg,socket
表头文件
#include < sys/socket.h >
定义函数
ssize_t send (int s,const void *msg,size_t len,int flags);
参数说明
第一个参数指定发送端套接字描述符；
第二个参数指明一个存放应用程式要发送数据的缓冲区；
第三个参数指明实际要发送的数据的字符数；
第四个参数一般置0。
函数说明
send() 用来将数据由指定的 socket 传给对方主机。使用 send 时套接字必须已经连接。send 不包含传送失败的提示信息，如果检测到本地错误将返回-1。因此，如果send 成功返回，并不必然表示连接另一端的进程接收数据。所保证的仅是当send 成功返回时，数据已经无错误地发送到网络上。
对于支持为报文设限的协议，如果单个报文超过协议所支持的最大尺寸，send 失败并将 errno 设为 EMSGSIZE ；对于字节流协议，send 会阻塞直到整个数据被传输。
flags 参数有如下的选择：
MSG_DONTROUTE 勿将数据路由出本地网络
MSG_DONTWAIT 允许非阻塞操作（等价于使用O_NONBLOCK）
MSG_EOR 如果协议支持，此为记录结束
MSG_OOB 如果协议支持，发送带外数据
MSG_NOSIGNAL 禁止向系统发送异常信息
返回值
成功则返回实际传送出去的字符数，失败返回－1，错误原因存于errno 中。
错误代码
EBADF 参数 s 非法的 socket 处理代码。
EFAULT 参数中有一指针指向无法存取的内存空间。
WNOTSOCK 参数 s 为一文件描述词，非 socket。
EINTR 被信号所中断。
EAGAIN 此动作会令进程阻断，但参数 s 的 socket 为不可阻断的。
ENOBUFS 系统的缓冲内存不足。
EINVAL 传给系统调用的参数不正确。
‘陆’ 在Linux下，在C中怎么调用C++的库函数
调用C++函数库，一般不能直接调用，需要将C++库转换成C接口输出，方可以使用C调用
将 C++ 函数声明为``extern "C"''（在你的 C++ 代码里做这个声明），然后调用它（在你的 C 或者 C++ 代码里调用）。例如：
// C++ code:
extern "C" void f(int);
void f(int i)
{
// ...
}
然后，你可以这样使用 f()：
/* C code: */
void f(int);
void cc(int i)
{
f(i);
/* ... */
}
当然，这招只适用于非成员函数。如果你想要在 C 里调用成员函数（包括虚函数），则需要提供一个简单的包装（wrapper）。例如：
// C++ code:
class C
{
// ...
virtual double f(int);
};
extern "C" double call_C_f(C* p, int i) // wrapper function
{
return p->f(i);
}
然后，你就可以这样调用 C::f()：
/* C code: */
double call_C_f(struct C* p, int i);
void ccc(struct C* p, int i)
{
double d = call_C_f(p,i);
/* ... */
}
如果你想在 C 里调用重载函数，则必须提供不同名字的包装，这样才能被 C 代码调用。例如：
// C++ code:
void f(int);
void f(double);
extern "C" void f_i(int i) { f(i); }
extern "C" void f_d(double d) { f(d); }
然后，你可以这样使用每个重载的 f()：
/* C code: */
void f_i(int);
void f_d(double);
void cccc(int i,double d)
{
f_i(i);
f_d(d);
/* ... */
}
注意，这些技巧也适用于在 C 里调用 C++ 类库，即使你不能（或者不想）修改 C++ 头文件。
再看下面的例子：
aa.cxx
#include "aa.h"
int sample::method()
{
cout<<"method is called!\n";
}
aa.h
#include
using namespace std;
class sample
{
public:
int method();
};
将上面的两个文件生成动态库libaa.so放到 /usr/lib目录下，编译命令如下
sudo g++ -fpic -shared -g -o /usr/lib/libaa.so aa.cxx -I ./
由于在C中不能识别类，所以要将上面类的成员函数封装成C接口函数输出，下面进行封装，将输出接口转换成C接口。
mylib.cxx
#include "add.h"
#ifndef _cplusplus
#define _cplusplus
#include "mylib.h"
#endif
int myfunc()
{
sample ss;
ss.method();
return 0;
}
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（）函数也能执行，这里介绍的是常规调用库函数的方法。
‘柒’ linux c signal函数
是第二次调用的时候输出的，第一次调用只是绑定了SIGUSR1的信号处理函数，不会进入该处理函数
为什么会有这样的输出呢？
signal函数是将信号与处理函数进行绑定，成功绑定则返回绑定之前的信号处理函数。那么来看看你的代码，第一次调用将sig_fun1绑定，无输出；第二次调用将sig_fun2绑定，也就是把sig_fun1替换下来，并且你还调用了它，参数为30，所以会有那样的输出。
该如何改呢？
其实你并没有涉及到linux的信号处理机制，光绑定是不够的，还需要发信号给它，才能真正进入信号处理过程。给你一个示例代码吧
#include<signal.h>
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
void sig_fun2(int signo)
{
printf("in sig_fun2:%d\n", signo);
}
void sig_fun1(int signo)
{
printf("in sig_fun1:%d\n", signo);
}
int main()
{
unsigned long i;
if (signal(SIGUSR1, sig_fun1) == SIG_ERR)
{
printf("signal fun1 error\n");
exit(1);
}
sleep(15);
(signal(SIGUSR1, sig_fun2))(30);
sleep(15);
printf("done\n");
return 0;
}
/****************************C 代码完，下面是如何运行***************************/
首先编译，假设生成可执行程序为test
然后运行，我用的是后台运行： nohup ./test>output.txt &
注意，这种方法要将输出重定向到文件output.txt（名字无所谓），然后你会看到一个数字，就是pid进程号
最后，在15秒之内发送信号：kill -SIGUSR1 进程号
现在你就可以打开output.txt看输出结果了。如果用sleep的话会被打断，所以只有两个输出加上替换处理函数时的输出共3个，也可以换成 int n=15;while(n--)sleep(1);
-------------------------------------------------------------
怎么样，加分吧
-------------------------------------------------------------
1.我就是想问第二次绑定sig_fun2的时候，调用了第一次绑定的sig_fun1么？
调用了， (signal(SIGUSR1, sig_fun2))(30);就是这一句， signal(SIGUSR1, sig_fun2)是个函数指针，你这样写就是调用它了，但是这和信号处理没关系，写成signal(SIGUSR1, sig_fun2);就可以了
这就是你所说的成功则返回绑定之前的函数？？？
对
那当时绑定sig_fun1的时候，返回之前的处理函数是什么？？
这个就是系统默认的了，比如SIGINT就是你ctrl+c取消程序执行发送的信号，它的处理函数就是结束程序的一系列动作，不过SIGUSR1是留给用户自定义的信号，系统默认应该是啥也不做的一个函数，例如void fun(int signo){}，你也可以第一次绑定的时候就调用试试看对不对
2.还有我在看signal函数定义的时候，void(//...)(int) 最后传入的这个int整形参数就是我们自定义sig_fun()中所接收的30么？？我看例子里面有的signal(SIGINT,myfunc)；也没有带参数啊，搞不懂
是你理解错了，signal函数只是绑定，没涉及到调用绑定函数，不用带参数，信号处理函数不是像你这样调用的。callback回调你知道吧，就是先做好一个函数或过程放着，事件触发的时候才调用。那个30是你用普通函数调用的方式时的参数，跟信号处理一点关系也没有，你用60，70也没半毛钱关系。我猜你是想要调用信号处理函数，然后迷糊了，其实我上面说的“kill -SIGUSR1 进程号”就是触发程序调用该处理函数的信号，这和kill -9 杀死进程一个道理，只不过处理函数不同，结果不一样。ctrl+c也可以用信号的方式发送，kill -2 进程号，或者 kill -SIGINT 进程号
另外,站长团上有产品团购,便宜有保证
‘捌’ linux下C语言有没有定时调用的函数
你是指延迟函数还是定时调用，比如到11:12:13秒执行某个函数？
如果是延时函数用
usleep(usec);//微妙
sleep(sec);//秒
如果是定时执行的话，你只能开个线程或while，每隔1s判断下当前系统时间，
structtm*ptm;
longts;
inty,m,d,h,n,s;
ts=time(NULL);
ptm=localtime(&ts);
y=ptm->tm_year+1900;//年
m=ptm->tm_mon+1;//月
d=ptm->tm_mday;//日
h=ptm->tm_hour;//时
n=ptm->tm_min;//分
s=ptm->tm_sec;//秒
照着上面的格式组成字符串进行判断，到点了就执行就可以了
‘玖’ linux下c语言环境变量操作的几个相关函数
这几个函数的原型在<stdio.h>中定义
/* Return the value of envariable NAME, or NULL if it doesn't exist. */
extern char *getenv (__const char *__name) __THROW __nonnull ((1)) __wur;
/* The SVID says this is in <stdio.h>, but this seems a better place. */
/* Put STRING, which is of the form "NAME=VALUE", in the environment.
If there is no `=', remove NAME from the environment. */
extern int putenv (char *__string) __THROW __nonnull ((1));
/* Set NAME to VALUE in the environment.
If REPLACE is nonzero, overwrite an existing value. */
extern int setenv (__const char *__name, __const char *__value, int __replace)
__THROW __nonnull ((2));
/* Remove the variable NAME from the environment. */
extern int unsetenv (__const char *__name) __THROW __nonnull ((1));
‘拾’ Linux C语言 malloc 函数
Queue的定义在哪
要转换类型 = (*类型)malloc(sizeof(类型))