linux函数指针的作用,结构体&函数指针

结构体中的指针函数以及“结构体”的继承

#include #include struct Fruit

{

void (*output)(void);

int i;

};

struct Apple

{

struct Fruit n;

void (*output)(void);

};

void output_base(void);

void output_driven(void);

void output_apple(void);

int main()

{

struct Fruit *p;

struct Apple *q;

struct Fruit base;

struct Apple driven;

base.i = 0;

base.output = output_base;

driven.n.i = 1;

driven.n.output = output_driven;

driven.output = output_apple;

p = &base;

printf("base's i is %d\n",p->i);

p->output();

p = (Fruit *)&driven;

printf("driven's i is %d\n",p->i);

q = &driven;

q->output();

getchar();

return 0;

}

void output_base(void)

{

printf("this is the base\n");

}

void output_driven(void)

{

printf("this is the driven\n");

}

void output_apple()

{

printf("this is apple's output\n");

}

******************************************************************

【相关帖子】结构体中指向函数的指针

结构体中指向函数的指针

C语言中的struct是最接近类的概念，但是在C语言的struct中只有成员，不能有函数，但是可以有指向函数的指针，这也就

方便了我们使用函数了。举个例子，如下：

#include #include #include typedef struct student

{

int id;

char name[50];

void (*initial)();

void (*process)(int id, char *name);

void (*destroy)();

}stu;

void initial()

{

printf("initialization...\n");

}

void process(int id, char *name)

{

printf("process...\n%d\t%s\n",id, name);

}

void destroy()

{

printf("destroy...\n");

}

int main()

{

stu *stu1;

//在VC和TC下都需要malloc也可以正常运行，但是linux gcc下就会出错，为段错误，必须malloc

stu1=(stu *)malloc(sizeof(stu));

// 使用的时候必须要先初始化

stu1->id=1000;

strcpy(stu1->name,"xufeng");

stu1->initial=initial;

stu1->process=process;

stu1->destroy=destroy;

printf("%d\t%s\n",stu1->id,stu1->name);

stu1->initial();

stu1->process(stu1->id, stu1->name);

stu1->destroy();

free(stu1);

return 0;

}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

c语言中，如何在结构体中实现函数的功能？把结构体做成和类相似，让他的内部有属性，也有方法

这样的结构体一般称为协议类，提供参考：

struct {

int funcid;

char *funcname;

int (*funcint)(); /* 函数指针 int 类型*/

void (*funcvoid)(); /* 函数指针 void类型*/

};

每次都需要初始化，比较麻烦

******************************************************************

【相关帖子】函数中使用结构体指针改变成员变量的值怎么不能传递到主函数中去

程序代码如下：

#include #include struct TNode

{

int data ;

TNode *lchild ;

TNode *rchild ;

} ;

void CreateTree(TNode *T , int A[] , int begin , int end)

{

if (begin > end)

{

T = NULL ;

return ;

}

int index = 0.5 * (begin + end) ;

T = (TNode*)malloc(sizeof(TNode)) ;

T->data = A[index] ;

CreateTree(T->lchild , A , begin , index - 1) ;

CreateTree(T->rchild , A , index + 1 , end) ;

}

void main()

{

int A[10] ;

for (int i = 0 ; i < 10 ; i++)

{

A[i] = i ;

}

TNode *T ;

CreateTree(T , A , 0 , 9) ;

cout << T->data << endl ;

}

程序运行不太对，错误就出在CreateTree函数中创建的T节点的的成员变量值没有传递出去，但是CreateTree函数的形参是指向结构体的指针啊，为什么会出现这种问题呢？

----------------------------------------------------------------------

void CreateTree(TNode* &T , int A[] , int begin , int end)

----------

改成对指针的引用...

--------------------------------------------------------

使用引用

--------------------------------------------------------

为什么要加引用呢？T已经是指向结构体的指针了，应该可以将改变后的信息传递到主函数中啊

-------------------------------------------------------

尽管加引用后运行结果是正确的

--------------------------------------------------------

因为需要将指针自身传出去

如果在函数外面分配空间就不需要引用了

--------------------------------------------------------如果需要改变变量的值，那么就应该传变量的指针(地址)，

如果需要改变指针的值，那么就应该传指针的指针(地址)。

--------------------------------------------------------

不用引用可以用指针的指针

void CreateTree(TNode **T , int A[] , int begin , int end)

{

TNode* newT;

if (begin > end)

{

T = NULL;

return;

}

int index = 0.5 * (begin + end);

newT = (TNode*)malloc(sizeof(TNode));

*T = newT;

newT->data = A[index] ;

CreateTree(&newT->lchild , A , begin , index - 1) ;

CreateTree(&newT->rchild , A , index + 1 , end) ;

}

void main()

{

int A[10] ;

for (int i = 0 ; i < 10 ; i++)

{

A[i] = i ;

}

TNode *T ;

CreateTree(&T , A , 0 , 9) ;

cout << T->data << endl ;

}

--------------------------------------------------------

哦，我明白了，谢谢各位了，结帖

******************************************************************************

【相关帖子】函数给作为参数传递的结构体指针的结构体成员赋值

char func(struct compABC *ABC)             正确

{

ABC->member1 = 12;

ABC->member2 = 34;

}

char func(struct compABC *ABC)   错误，根据 K&R C 相关章节的说明，-> 运算符也比 * 优先

{

*ABC->member1 = 12;

*ABC->member2 = 34;

}

char func(struct compABC *ABC)        错误，点号(.)比星号(*)优先

{

*ABC.member1 = 12;

*ABC.member2 = 34;

}

char func(struct compABC *ABC)               正确

{

(*ABC).member1 = 12;

(*ABC).member2 = 34;

}

附:什么是 K&R C

C语言由Dennis M. Ritchie在1973年设计和实现。从那以后使用者逐渐增加。到1978年Ritchie和Bell实验室的另一位程序专家Kernighan合写了著名的《The C Programming Language》，将C语言推向全世界，许多国家都出了译本，国内有一些C语言书就是这本书的翻译或者编译。由这本书定义的C语言后来被人们称作 K&R C。

随着C语言使用得越来越广泛，出现了许多新问题，人们日益强烈地要求对C语言进行标准化。这个标准化的工作在美国国家标准局(ANSI)的框架中进行(1983-1988)，最终结果是1988年10月颁布的ANSI标准X3.159-1989，也就是后来人们所说的ANSI C标准。由这个标准定义的C语言被称作ANSI C。

ANSI C标准很快被采纳为国际标准和各国的标准。国际标准为ISO/IEC 9899-1990，中国国家标准GB/T 15272-94是国际ISO标准的中文翻译。

ANSI C标准化工作的一个主要目标是清除原来C语言中的不安全、不合理、不精确、不完善的东西。由此也产生了ANSI C与K&R C之间的差异。从总体上看，这些差异反应的是C语言走向完善、走向成熟。

ANSI C 对 K&R C 的修订

(本段根据《C Programming Language》和C语言标准整理。不求完整，希望列出最常见的差异)

对于源文件内部的标识符，有效的最小长度扩充到31个字符。文件间连接时，标识符的最小有效长度仍然为6个字符。(许多实现都支持更大的长度)

增加了几个新关键字：void，const，volatile，signed，enum。抛弃了老关键字entry。

在换意字符 \ 之后写非规定的序列，其作用确定为无定义。

规定8和9都不是八进制数的合法字符。

引进了数的后缀字符：整数的U和L，浮点数的F和L。

规定连续出现的字符串常量将被拼接在一起。

引进了“宽字符”的概念。

将字符也确定为带符号(signed)和不带符号(unsigned)的。

丢弃了long float(原来作为double的同义词)。

引入了void类型，用 (void*) 表示通用指针的类型(过去人们通常用 (char*))。

对算术类型规定了最小表示范围。要求每个C语言系统用头文件(和)说明实现中的具体规定。

引进了枚举定义enum。

采用了来自C++的类型修饰符，如const。

规定字符串常量是不可修改的。

改变了算术类型的隐含转换规则。

删去了一些过时赋值运算符，如 =+。规定赋值运算符都是基本单词，如 += 之间不能有空格分隔。

引进了与一元 - 运算符对应的一元 + 运算符。

指向函数的指针可以直接放在函数调用的位置，不必显式地写间接操作。

允许结构地整体赋值，作为函数参数和返回值传递。

允许将取地址运算符作用于数组，得到的是指向有关数组的指针。

标准规定 sizeof 运算符的返回值为 size_t 类型(某个无符号整型)，这一类型在标准头文件里定义。同时在那里定义的还有 ptrdiff_t 类型，它是指针减运算的结果类型。

规定取地址运算符不能作用于 register 变量。

规定移位表达式的类型为其左运算对象的类型。

允许建立指向过数组末元素一个位置的指针，以及对它的算术运算和关系运算。

(从C++)引进了包含参数类型的函数原型概念，引进了变长参数表函数的概念。仍允许老的形式，但仅仅是作为过时形式保留。

标准规定任何局部声明的作用域仅仅是当前的块(复合语句)。

规定函数参数作为加入函数体(复合语句)的声明，因此不能用变量声明去覆盖。

有关名字空间的规定：所有结构、联合和枚举标记在一个名字空间里，标号是另一个名字空间。

联合变量在定义时也可以初始化，规定初始化其第一个成分。

自动结构、联合和数组也可以初始化，但限制其初始化方式(其中只能包含常量表达式)。

带大小描述的字符数组也可以用大小与之相同的字符串常量初始化(结束的 \0 被删除)。

开关语句的控制表达式和case标号可以是任何整型的(包括字符类型)。