C Implements object-oriented

Object-oriented is simply encapsulation inheritance and polymorphism

Encapsulation: struct IMPLEMENTATION

Inheritance: pointer implementation, which is to include the parent class in the struct.

Polymorphic: can be implemented with pointers.

Generally implemented polymorphism, the parent struct must be the first element of a child struct, so that it can be cast arbitrarily by casting subclasses and parent classes.

Structures such as:

[CPP]View Plaincopy

2. struct parent{
4. int A;
6. };
8. struct child{
10. struct parent p;
12. int b;
14. };
16. That's why the following conversions
18. struct Child *c= (struct Child *) malloc (sizeof (struct-child));
20. c->p.a=10;
22. struct Child *c= (struct Child *) & (C->P);
24. There are many C languages that use the first address to convert the type

And the Linux kernel polymorphism is not the way to achieve

General and Containof () and void *

->: Used to get the parent class

Containof (): Used to get subclasses from parent class

void *: Equivalent to the object class in Java can convert a class to void * and then convert it back elsewhere. Long is used in the parameters of the function.

Such as:

[CPP]View Plaincopy

2. #include <stdio.h>
6. struct base{
8. int A;
10. Char b;
12. };
16. struct subclass{
18. struct base *mybase;
20. int s_a;
22. Char S_b;
24. };
30. void Test (struct base *base)
32. {
34. //Forces pointer base pointing to struct struct base to pointer to struct subclass sub
36. //Here is the downward transformation
38. //struct Subclass *sub= (struct subclass *) base;
40. struct Subclass *sub=base;
42. printf ("a:%d\tb:%c\n", sub->mybase->a,sub->mybase->b);
44. /*some operations*/
46. }
50. void Main (void)
52. {
54. struct Subclass *mysub= (struct subclass *) malloc (sizeof (mysub));
56. mysub->mybase= (struct base *) malloc (sizeof (struct base));
58. mysub->mybase->a=10;
60. mysub->mybase->b=' A ';
62. mysub->s_a=11;
64. mysub->s_b=' B ';
66. //Here is the upward transformation,
68. //This is not like Java and C + + can automatically transform upward, all must be manually,
70. //This does not mean that if you do not convert with an expression, there will be problems .
72. //Because our class here is not a real class, there will be obvious inheritance in C + + or Java such as A:base
74. struct base *mybase;
76. Mybase=mysub;
78. Test (MyBase);
80. }

PS: Some other articles

From: http://blog.chinaunix.net/uid-26750235-id-3102371.htmlhttp://blog.chinaunix.net/uid-26750235-id-3102371.html

       In geometry, all geometry types inherit the parent class shape, and the parent class shape has two properties S_type and S_name. Where S_type is used to represent the type to which the shape belongs, S_name is used to name the table in that shape state. And the parent shape has two virtual interfaces, one for Shape_area to return the shape's area, and one for Shape_perimeter to return the perimeter of the shape. Both interfaces must be implemented by subclasses of the child's inherited shape.

1. Struct shape;
2. Struct shape_ops
3. {
4.     /* returns the area of the geometry */
5.     float  (*so_area) ( struct shape*);  
6.     /* Returns the perimeter of the geometry */
7.     int   (*so_perimeter) (struct shape*);
8. };
9. Struct shape
10. {
11.     int* s_type;
12.     Char* s_name;
13.     struct shape_ops* s_ops; /* Virtual interface, all subclasses must implement */
14. };
16. Float shape_area (struct shape* s)  /* shape area */
17. {
18.      return s->s_ops->so_area (s);  
19. }
20. Int shape_perimeter (struct shape* s)/* for perimeter */
21. {
22.  & Nbsp;  return s->s_ops->so_perimeter (s);
23. }

The geometry "triangle (triangle)" Inherits the parent class "shape" and implements the two virtual interfaces of the parent class. The "triangle" has three sides, respectively, with T_side_a,t_side_b,t_side_c to the length of the three sides.

2. /* Triangle */
4. struct triangle
6. {
8. struct shape t_base;
10. int t_side_a;
12. int t_side_b;
14. int T_side_c;
16. };
20. float Triangle_area (struct shape* s)/* Triangle area, with Helen Formula */
22. {
24. struct triangle* t= (struct triangle*) s;
26. int a=t->t_side_a;
28. int b=t->t_side_b;
30. int c=t->t_side_c;
32. Float p= (a+b+c)/2;
34. return sqrt (p* (p-a) * (p-b) * (p-c));
36. }
38. int Triangle_perimeter (struct shape* s)/* triangle circumference */
40. {
42. struct triangle* t= (struct triangle*) s;
44. int a=t->t_side_a;
46. int b=t->t_side_b;
48. int c=t->t_side_c;
50. return a+b+c;
52. }
54. struct Shape_ops triangle_ops=/* Implementation of the parent virtual interface */
56. {
58. Triangle_area,
60. Triangle_perimeter,
62. };
64. struct triangle* triangle_create (int a,int b,int c)/* Create triangle */
66. {
68. struct triangle* ret= (struct triangle*) malloc (sizeof (*ret));
70. Ret->t_base.s_name= "triangle";
72. ret->t_base.s_ops=&triangle_ops;
74. ret->t_side_a=a;
76. ret->t_side_b=b;
78. ret->t_side_c=c;
80. return ret;
82. }

The geometry "Rectangle (Rectangle)" Inherits the parent class "shape", which also implements the two virtual interfaces of the parent class. There are two properties R_width and R_height, each representing the length and width of the rectangle.

2. /* Rectangle */
4. struct Rectangle
6. {
8. struct shape r_base;
10. int r_width;
12. int r_height;
14. };
18. float Rectangle_area (struct shape* s)/* rectangular area */
20. {
22. struct rectangle* r= (struct rectangle*) s;
24. Return r->r_width*r->r_height;
26. }
28. int Rectangle_perimeter (struct shape* s)/* Rectangle circumference */
30. {
32. struct rectangle* r= (struct rectangle*) s;
34. Return (r->r_width+r->r_height) * *;
36. }
38. struct Shape_ops rectangle_ops=/* Implementation of the parent virtual interface */
40. {
42. Rectangle_area,
44. Rectangle_perimeter,
46. };
50. struct rectangle* rectangle_create (int width, int height)/* Create rectangle */
52. {
54. struct rectangle* ret= (struct rectangle*) malloc (sizeof (*ret));
56. Ret->r_base.s_name= "Rectangle";
58. ret->r_base.s_ops=&rectangle_ops;
60. ret->r_height=height;
62. ret->r_width=width;
64. return ret;
66. }

Test code:

2. int main ()
4. {
6. struct shape* s[4];
8. S[0]=triangle_create (5,5,4);
10. S[1]=triangle_create (3,4,5);
12. S[2]=rectangle_create (10,12);
14. S[3]=rectangle_create (5,8);
18. int i=0;
20. for (i=0;i<4;i++)
22. {
24. Float Area=shape_area (s[i]);
26. int Perimeter=shape_perimeter (s[i]);
28. char* name=s[i]->s_name;
32. printf ("name:%s, area:%.2f, perimeter:%d\n", name,area,perimeter);
34. }
36. return 0;
38. }

Operation Result:

1. Name:triangle, area:9.17, perimeter:14
2. Name:triangle, area:6.00, Perimeter:12
3. Name:rectangle, area:120.00, perimeter:44
4. Name:rectangle, area:40.00, perimeter:26

From: http://blog.csdn.net/kennyrose/article/details/7564105

Recently, during the interview process, students were asked such a question: How to achieve object-oriented with C language? We all know the three basic features of object-oriented: encapsulation, inheritance and polymorphism, the C + + language and compilers all have strong support for these features, but how to implement object-oriented for a functional language like C? Quote a WORD: object-oriented is always thought, not language! Understanding object-oriented programming ideas, we use the C language, such as lower-level language can also be implemented OOP, which is specifically used in the C language of the macro, structure, function pointers, aggregation and other knowledge.

It is highly recommended to refer to the following links

Http://blog.codingnow.com/2010/03/object_oriented_programming_in_c.html

Http://c.group.iteye.com/group/wiki/1291-object-oriented-programming-language-c

Http://blog.chinaunix.net/uid-26750235-id-3102371.html

Http://blog.chinaunix.net/uid-9104650-id-2009591.html

Http://liujian.is-programmer.com/posts/268.html

http://blog.csdn.net/yuyin86/article/details/7107671#

Two books recommended:

"Inside the C + + Object Model"

"Object-oriented Programming with Ansi-c"

This is the Chinese translation of Csdn's previous chapters.

http://blog.csdn.net/besidemyself/article/details/6376405

All the Chinese and English translations on the wiki

Http://wiki.chinaunix.net/OOC:%e5%86%85%e5%ae%b9

However, we recommend reading against the original English

Http://www.planetpdf.com/codecuts/pdfs/ooc.pdf

Here are some examples of object-oriented programming with ANSI-C

Http://www.bolthole.com/OO-C-programming.html

Http://barracudaserver.com/WP/DeviceControl/OOIntro.html

Http://www.eventhelix.com/realtimemantra/basics/object_oriented_programming_in_c.htm

Here are some of the OOP design ideas and principles of the article

http://www.eventhelix.com/realtimemantra/Object_Oriented/

The following article gives C + + and corresponding C code, C for the implementation of C + + inheritance and virtual function characteristics, recommended @ ^ @

Http://www.eventhelix.com/realtimemantra/basics/ComparingCPPAndCPerformance2.htm

The following is a lightweight object-oriented C programming framework LW--OOPC(light Weight object-oriented Programming with C)

http://sourceforge.net/projects/lwoopc/

Here's a video tutorial above Youku (I haven't seen it yet)

Http://v.youku.com/v_show/id_XMTM4MzkyMTI4.html

Accidentally found a "C language can do great things."

Http://www.rupeng.com/forum/forum-52-1.html

If you are interested, you can also learn about Objective-c, which is a C-language master that joins object-oriented thinking

Http://zh.wikipedia.org/wiki/Objective-C

Http://www.apple.com.cn/developer/mac/library/documentation/Cocoa/Conceptual/OOP_ObjC/Introduction/chapter_1_ Section_1.html#//apple_ref/doc/uid/tp40005149-ch1-sw2

• • C Language Object-oriented programming (i): Encapsulation and inheritance
  • C Language Object-oriented programming (II): inheritance Explained
  • C Language Object-oriented programming (III): virtual function and polymorphism
  • C Language Object-oriented programming (IV): interface-oriented programming
  • C Language Object-oriented programming (V): single-linked list implementation
  • C Language Object-oriented programming (VI): Configuration file parsing

C Implement object-oriented (GO)