A. 有没有在PowerShell中的函数指针或函数数组
指针数组是指针的数组，把这句话重复三遍
这个数组里放的满满的都是指针
数组指针是一个指针，这个指针指向一个数组
同理函数指针指向一个函数，只是个变量
指针函数是指带指针的函数，即本质是一个函数
int *f(x，y);
是很绕人
B. 调用一个动态库中的函数，这个函数有一个参数是结构体指针，我如何使用这个指针
你就也定义一个形参中的结构体指针接收传过来的结构体指针就OK啦
形参中的结构体指针改变？这什么意思?
给你看个例子吧:
struct node *creat(struct node *l)
{
struct node *head;
head=l;
return head;
}
你是这样吗~
C. 简单的shell编程
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#define BUFFERSIZE 80
extern char *get_current_dir_name(void);
extern char *getenv(const char *name);
extern pid_t waitpid(pid_t pid, int *status, int options);
char buffer[BUFFERSIZE+1];
main()
{
char *path, *arg[10], *input;
int li_inputlen, is_bj, is_back, i, j, k, pid, status;
char lc_char;
while (1){
/* initiations */
is_bj = 0; /*redirection flag*/
is_back = 0; /*background*/
/* shell prompt */
path = get_current_dir_name();
printf("%s>$",path);
/*开始获取输入*/
li_inputlen = 0;
lc_char = getchar();
while (lc_char !='\n'){
if(li_inputlen < BUFFERSIZE)
buffer[li_inputlen++] = lc_char;
lc_char = getchar();
}
/*命令超长处理*/
if (li_inputlen >= BUFFERSIZE){
printf("Your command is too long! Please re-enter your command!\n");
li_inputlen = 0; /*reset */
continue;
}
else
buffer[li_inputlen] = '\0';/*加上串结束符号，形成字串*/
/*将命令从缓存拷贝到input中*/
input = (char *) malloc(sizeof(char) * (li_inputlen+1));
strcpy(input,buffer);
/* 获取命令和参数并保存在arg中*/
for (i = 0,j = 0,k = 0;i <= li_inputlen;i++){
/*管道和重定向单独处理*/
if (input[i] == '<' || input[i] == '>' || input[i] =='|'){
if (input[i] == '|')
pipel(input,li_inputlen);
else
redirect(input,li_inputlen);
is_bj = 1;
break;
}
/*处理空格、TAB和结束符。不用处理‘\n'，大家如果仔细分析前面的获取输入的程序的话，
*不难发现回车符并没有写入buffer*/
if (input[i] == ' ' || input[i] =='\t' || input[i] == '\0'){
if (j == 0) /*这个条件可以略去连在一起的多个空格或者tab*/
continue;
else{
buffer[j++] = '\0';
arg[k] = (char *) malloc(sizeof(char)*j);
/*将指令或参数从缓存拷贝到arg中*/
strcpy(arg[k],buffer);
j = 0; /*准备取下一个参数*/
k++;
}
}
else{
/*如果字串最后是‘&'，则置后台运行标记为1*/
if (input[i] == '&' && input[i+1] == '\0'){
is_back = 1;
continue;
}
buffer[j++] = input[i];
}
}
free(input);/*释放空间*/
/*如果输入的指令是leave则退出while，即退出程序*/
if (strcmp(arg[0],"leave") == 0 ){
printf("bye-bye\n");
break;
}
/*如果输入的指令是about则显示作者信息，同时结束本条命令的解析过程*/
if (strcmp(arg[0]," about") == 0 ){
printf("right by shike，[email protected]\n");
continue;
}
if (is_bj == 0){ /*非管道、重定向指令*/
/*在使用xxec执行命令的时候，最后的参数必须是NULL指针，
*所以将最后一个参数置成空值*/
arg[k] = (char *) 0;
/*判断指令arg[0]是否存在*/
if (is_fileexist(arg[0]) == -1 ){
printf("This command is not found?!\n");
for(i=0;i<k;i++)
free(arg[i]);
continue;
}
/* fork a sub-process to run the execution file */
if ((pid = fork()) ==0) /*子进程*/
execv(buffer,arg);
else /*父进程*/
if (is_back == 0) /*并非后台执行指令*/
waitpid(pid,&status,0);
/*释放申请的空间*/
for (i=0;i<k;i++)
free(arg[i]);
}
}
}
int is_fileexist(char *comm)
{
char *path,*p;
int i;
i = 0;
/*使用getenv函数来获取系统环境变量，用参数PATH表示获取路径*/
path = getenv("PATH");
p = path;
while (*p != '\0'){
/*路径列表使用‘:’来分隔路径*/
if (*p != ':')
buffer[i++] = *p;
else{
buffer[i++] = '/';
buffer[i] = '\0';
/*将指令和路径合成，形成pathname，并使用access函数来判断该文件是否存在*/
strcat(buffer,comm);
if (access(buffer,F_OK) == 0) /*文件被找到*/
return 0;
else
/*继续寻找其它路径*/
i = 0;
}
p++;
}
/*搜索完所有路径，依然没有找到则返回-1*/
return -1;
}
int redirect(char *in,int len)
{
char *argv[30],*filename[2];
pid_t pid;
int i,j,k,fd_in,fd_out,is_in = -1,is_out = -1,num = 0;
int is_back = 0,status=0;
/*这里是重定向的命令解析过程，其中filename用于存放重定向文件，
*is_in, is_out分别是输入重定向标记和输出重定向标记*/
for (i = 0,j = 0,k = 0;i <= len;i++){
if (in[i]==' '||in[i]=='\t'||in[i]=='\0'||in[i] =='<'||in[i]=='>'){
if (in[i] == '>' || in[i] == '<'){
/*重定向指令最多'<'，'>'各出现一次，因此num最大为2，
*否则认为命令输入错误*/
if (num < 3){
num ++;
if (in[i] == '<')
is_in = num - 1;
else
is_out = num - 1;
/*处理命令和重定向符号相连的情况，比如ls>a*/
if (j > 0 && num == 1) {
buffer[j++] = '\0';
argv[k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[k],buffer);
k++;
j = 0;
}
}
else{
printf("The format is error!\n");
return -1;
}
}
if (j == 0)
continue;
else{
buffer[j++] = '\0';
/*尚未遇到重定向符号，字符串是命令或参数*/
if (num == 0){
argv[k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[k],buffer);
k++;
}
/*是重定向后符号的字符串，是文件名*/
else{
filename[status] = (char *) malloc(sizeof(char)*j);
strcpy(filename[status++],buffer);
}
j = 0; /*initate*/
}
}
else{
if (in[i] == '&' && in[i+1] == '\0'){
is_back = 1;
continue;
}
buffer[j++] = in[i];
}
}
argv[k] = (char *) 0;
if (is_fileexist(argv[0]) == -1 ){
printf("This command is not founded!\n");
for(i=0;i<k;i++)
free(argv[i]);
return 0;
}
if ((pid = fork()) ==0){
/*存在输出重定向*/
if (is_out != -1)
if((fd_out=open(filename[is_out],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1){
printf("Open out %s Error\n",filename[is_out]);
return -1;
}
/*存在输入重定向*/
if (is_in != -1)
if((fd_in=open(filename[is_in],O_RDONLY,S_IRUSR|S_IWUSR))==-1){
printf("Open in %s Error\n",filename[is_out]);
return -1;
}
if (is_out != -1)
/*使用p2函数将标准输出重定向到fd_out上，p2(int oldfd,int newfd)实现的
*是把oldfd所指的文件描述符复制到newfd。若newfd为一已打开的文件描述词，
*则newfd所指的文件会先被关闭，p2复制的文件描述词与原来的文件描述词
*共享各种文件状态*/
if(p2(fd_out,STDOUT_FILENO)==-1){
printf("Redirect Standard Out Error\n");
exit(1);
}
if (is_in != -1)
if(p2(fd_in,STDIN_FILENO)==-1){
printf("Redirect Standard Out Error\n");
exit(1);
}
execv(buffer,argv);
}
else
if (is_back == 0) /*run on the TOP*/
waitpid(pid,&status,0);
for (i=0;i<k;i++)
free(argv[i]);
if (is_in != -1){
free(filename[is_in]);
close(fd_in);
}
if (is_out != -1){
free(filename[is_out]);
close(fd_out);
}
return 0;
}
int pipel(char *input,int len)
{
char *argv[2][30];
int i,j,k,count,is_back = 0;
int li_comm = 0,fd[2],fpip[2];
char lc_char,lc_end[1];
pid_t child1,child2;
/*管道的命令解析过程*/
for (i = 0,j = 0,k = 0;i <= len;i++){
if (input[i]== ' ' || input[i] == '\t' || input[i] == '\0' || input[i] == '|'){
if (input[i] == '|' ) /*管道符号*/
{
if (j > 0)
{
buffer[j++] = '\0';
/*因为管道连接的是两个指令，所以用二维数组指针来存放命令和参数，
*li_comm是表示第几个指令*/
argv[li_comm][k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[li_comm][k++],buffer);
}
argv[li_comm][k++] = (char *) 0;
/*遇到管道符，第一个指令完毕，开始准备接受第二个指令*/
li_comm++;
count = k;
k=0;j=0;
}
if (j == 0)
continue;
else
{
buffer[j++] = '\0';
argv[li_comm][k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[li_comm][k],buffer);
k++;
}
j = 0; /*initate*/
}
else{
if (input[i] == '&' && input[i+1] == '\0'){
is_back = 1;
continue;
}
buffer[j++] = input[i];
}
}
argv[li_comm][k++] = (char *) 0;
if (is_fileexist(argv[0][0]) == -1 ){
printf("This first command is not found!\n");
for(i=0;i<count;i++)
free(argv[0][i]);
return 0;
}
/*指令解析结束*/
/*建立管道*/
if (pipe(fd) == -1 ){
printf("open pipe error!\n");
return -1;
}
/*创建第一个子进程执行管道符前的指令，并将输出写到管道*/
if ((child1 = fork()) ==0){
/*关闭读端*/
close(fd[0]);
if (fd[1] != STDOUT_FILENO){
/*将标准输出重定向到管道的写入端，这样该子进程的输出就写入了管道*/
if (p2(fd[1],STDOUT_FILENO) == -1){
printf("Redirect Standard Out Error\n");
return -1;
}
/*关闭写入端*/
close(fd[1]);
}
execv(buffer,argv[0]);
}
else{ /*父进程*/
/*先要等待写入管道的进程结束*/
waitpid(child1,&li_comm,0);
/*然后我们必须写入一个结束标记，告诉读管道进程数据到这里就完了*/
lc_end[0] = 0x1a;
write(fd[1],lc_end,1);
close(fd[1]);
if (is_fileexist(argv[1][0]) == -1 ){
printf("This command is not founded!\n");
for(i=0;i<k;i++)
free(argv[1][i]);
return 0;
}
/*创建第二个进程执行管道符后的指令，并从管道读输入流 */
if ((child2 = fork()) == 0){
if (fd[0] != STDIN_FILENO){
/*将标准输入重定向到管道读入端*/
if(p2(fd[0],STDIN_FILENO) == -1){
printf("Redirect Standard In Error!\n");
return -1;
}
close(fd[0]);
}
execv(buffer,argv[1]);
}
else /*父进程*/
if (is_back == 0)
waitpid(child2,NULL,0);
}
for (i=0;i<count;i++)
free(argv[0][i]);
for (i=0;i<k;i++)
free(argv[1][i]);
return 0;
}
以前写的，好像一些细节不一样，不明白的地方，发邮件给我，[email protected]
D. 直接调用函数与通过函数指针调用有什么不一样
函数指针是指向函数的指针变量。也就是说，它是一个指针变量，而且该指针指向一个函数。
对于指针变量来说，它的值是它指向的变量的地址。举个例子：指针变量pi是指向一个整型变量i的指针，则变量i的地址 &i 就是指针变量pi的值。也就是说整型变量指针指向一个整型变量，而整型变量指针的值就是它所指的整型变量的地址。与其它类型指针变量一样，函数指针变量的值就是它指向的函数的地址。
那么什么是函数的地址呢？
我们首先来看函数调用是怎么回事。在程序运行时，一个函数占用一段连续的内存。当调用一个函数时，实际上是跳转到函数的入口地址，执行函数体的代码，完成后返回。
函数指针指向一个函数的入口地址，也就是函数存储空间的首地址。
在C语言中，数组名代表数组的首地址，同样函数名代表了函数的首地址，因此在赋值时，直接将函数指针指向函数名就行了。
函数指针的定义
一般，函数指针的定义格式为：
函数类型 (*指针变量名)(形参列表);
“函数类型”说明函数的返回类型，由于“()”的优先级高于“*”，所以指针变量名外的括号必不可少，后面的“形参列表”表示指针变量指向的函数所带的参数列表。
例如：对于函数int f(int a)，我们定义一个指向该函数的函数指针fp，采用如下格式：
int (*fp)(int a);
函数指针的赋值
前面我们已经讲到，在C语言中，函数名代表了函数的首地址，因此在赋值时，直接将函数名赋值给函数指针就可以了。
例如：
int func(int x); //声明一个函数
int (*fp)(int x); //定义一个函数指针
fp = func; //将func函数的首地址赋值给指针fp
赋值时函数func不带括号，也不带参数，由于func代表函数的首地址，因此经过赋值以后，指针就指向函数func(x)的代码的首地址。
通过函数指针调用函数
与其它指针变量相类似，如果指针变量pi是指向某整型变量i的指针，则*pi等于它所指向的变量i；如果pf是指向某浮点型变量f的指针，则*pf就等价于它所指的变量f。同样地，fp是指向函数func(x)的指针，则*fp就代表它所指向的函数func。所以在执行了fp = func;之后，(*fp)和func代表同一函数。
由于函数指针指向存储区中的某个函数，因此可以通过函数指针调用相应的函数。
用函数指针调用函数由三步组成：
首先，定义函数指针变量。
例如：int (*fp)(int x);
然后，给函数指针变量赋值。
例如：fp = func; （func(x)必须要先有定义）
最后，用(*指针变量)(参数表);调用函数。
例如：(*fp)(x);（x必须先赋值）。
在这里，(*fp)(x);一般写成fp(x); fp(x)是标准C++的写法，(*fp)(x);是兼容C语言的标准写法。
总结以上知识，举例说明
到目前为止，相信您已经简单了解了函数指针，下面我们举一个简单的、完整的程序进行说明。
E. Linux.,,,,,,,shell语言，
参数type可使用“r”代表读取，“w”代表写入。依照此type值，popen()会建立管道连到子进程的标准输出设备或标准输入设备，然后返回一个文件指针。随后进程便可利用此文件指针来读取子进程的输出设备或是写入到子进程的标准输入设备中。此外，所有使用文件指针(FILE*)操作的函数也都可以使用，除了fclose()以外。 返回值：若成功则返回文件指针，否则返回NULL，错误原因存于errno中。 注意：在编写具SUID/SGID权限的程序时请尽量避免使用popen()，popen()会继承环境变量，通过环境变量可能会造成系统安全的问题。 例：C程序popentest.c内容如下： #include<stdio.h> main() { FILE * fp; charbuffer[80]; fp=popen(“~/myprogram/test.sh”,”r”); fgets(buffer,sizeof(buffer),fp); printf(“%s”,buffer); pclose(fp); } 执行结果如下： xiakeyou@ubuntu:~/myprogram$ vim popentest.c xiakeyou@ubuntu:~/myprogram$ gcc popentest.c -o popentest xiakeyou@ubuntu:~/myprogram$ ./popentest /home/d/e/xiakeyou xiakeyou@ubuntu:~/myprogram$ 只是偶能力可能有点有限，没有太看懂。直接用system()倒是脚本可是执行，只是返回值却是一塌糊涂，试了多次也没有找到什么规律。不免又看了一下上面的那篇博文，得到一些启发，可以这样来实现： 先将脚本的返回值利用 echo > XXXXX 输出到一个本地文件中 当需要这个返回值是，可是通过C语言的文件操作函数来直接从文件中读取 后来一想，这应该就是上文中POPEN的实现方法！ C程序调用shell脚本共有三种法子 ：system()、popen()、exec系列函数 system() 不用你自己去产生进程，它已经封装了，直接加入自己的命令exec 需要你自己 fork 进程，然后exec 自己的命令 popen() 也可以实现执行你的命令，比system 开销小 1）system(shell命令或shell脚本路径); system()会调用fork()产生 子历程，由子历程来调用/bin/sh-c string来履行 参数string字符串所代表的命令，此命令履行 完后随即返回原调用的历程。在调用system()期间SIGCHLD 信号会被暂时搁置，SIGINT和SIGQUIT 信号则会被漠视 。 返回值：如果system()在调用/bin/sh时失败则返回127，其他失败原因返回-1。若参数string为空指针(NULL)，则返回非零值。 如果 system()调用成功 则最后会返回履行 shell命令后的返回值，但是此返回值也有可能为system()调用/bin/sh失败所返回的127，因 此最好能再反省 errno 来确认履行 成功 。 system命令以其简略 高效的作用得到很很广泛 的利用 ，下面是一个例子 例：在~/test/目录下有shell脚本test.sh，内容为 #!bin/bash #test.sh echo hello 在同层目录下新建一个c文件system_test.c，内容为： #include<stdlib.h> int main() { system("~/test/test.sh"); } 履行 效果 如下： [root@localhost test]$gcc system_test.c -o system_test [root@localhost test]$./system_test hello [root@localhost test]$ 2）popen(char *command,char *type) popen()会调用fork()产生 子历程，然后从子历程中调用/bin/sh -c来履行 参数command的指令。参数type可应用 “r”代表读取，“w”代表写入。遵循此type值，popen()会建立 管道连到子历程的标准 输出设备 或标准 输入设备 ，然后返回一个文件指针。随后历程便可利用 此文件指针来读取子历程的输出设备 或是写入到子历程的标准 输入设备 中。此外，所有应用 文 件指针(FILE*)操作的函数也都可以应用 ，除了fclose()以外。 返回值：若成功 则返回文件指针，否则返回NULL，差错 原因存于errno中。
打字不易，如满意，望采纳。