嵌入式八股C语言---面向对象篇

面向对象与面向过程

• 面向过程
  就是把整个业务逻辑分成多个步骤,每步或每一个功能都可以使用一个函数来实现
• 面向对象
  对象是类的实例化,此时一个类就内部有属性和相应的方法

封装

  在C语言里实现封装就是实现一个结构体,里面包括的成员变量和函数指针,然后在构造函数中,为结构体的函数指针赋初值
对于这个函数指针往往会把自身传入,因为只是在模仿class

#include <stdio.h>
#include <stdlib.h>
struct student
{int height;char* name;void(*add_height)(struct student *, int);
};void ADD_HEIGHT(struct student * stu, int add)
{stu->height += add;
}
struct student * Student(int height,char *name)
{struct student * stu = malloc(sizeof(struct student));if(stu) {stu->height = height;stu->name = name;stu->add_height = ADD_HEIGHT;}return stu;
}
void freeStudent(struct student * stu )
{if(stu) {free(stu);stu = NULL;}
}
int main()
{struct student * stu = Student(180,"LCS");printf("%d\r\n",stu->height);stu->add_height(stu,50);printf("%d\r\n",stu->height);return 0;
}

继承

• 实现方案一: 子类中嵌套父类结构体指针
  C语言模仿继承就是子类的结构体里嵌套一个父类的结构体
  那如何实现类似虚函数的效果呢–修改父类的函数指针的指向就行

 		#include <stdio.h>#include <stdlib.h>struct animal{/* data */int age;void (*speak)(void);};void cat_speak() {printf("speak miaomiao\r\n");}void dog_speak() {printf("speak wangwang\r\n");}struct cat {struct animal * anm;int like_nothing;};struct dog {struct animal * anm;int like_eat_shit;};struct animal* Animal(int age) {struct animal* anm = malloc(sizeof(struct animal));anm->age = age;anm->speak = NULL;return anm;}struct cat* Cat(int age) {struct cat* new_cat = malloc(sizeof(struct cat));new_cat->anm = Animal(age); // 这就意味着等会你释放内存是真麻烦new_cat->like_nothing = 1;new_cat->anm->speak = cat_speak;return new_cat;}struct dog* Dog(int age) {struct dog* new_dog = malloc(sizeof(struct dog));new_dog->anm = Animal(age); // 这就意味着等会你释放内存是真麻烦new_dog->like_eat_shit = 1;new_dog->anm->speak = dog_speak;return new_dog;}int main(){struct cat* new_cat = Cat(5);struct dog* new_dog = Dog(10);new_cat->anm->speak();new_dog->anm->speak();return 0;}

• 继承的妙用: struct list_head 双向链表
    当我们想要实现自己的列表的实现 就把自己的链表中嵌入这个双向列表就行
• 实现方案二: 父类提供一个void * 私有指针 不同的子类把void * 做不同的实现

#include <stdio.h>
#include <stdlib.h>// 基类定义
typedef struct {int age;void (*speak)(void*); // 虚函数指针void* private_data;   // 用于存储子类特定数据
} Animal;// Cat的私有数据结构
typedef struct {int like_nothing;
} CatPrivate;// Dog的私有数据结构
typedef struct {int like_eat_shit;
} DogPrivate;// 实现虚函数：猫叫声
static void cat_speak(void* obj) {CatPrivate* private_data = ((Animal*)obj)->private_data;printf("Cat says: miaomiao, like_nothing=%d\n", private_data->like_nothing);
}// 实现虚函数：狗叫声
static void dog_speak(void* obj) {DogPrivate* private_data = ((Animal*)obj)->private_data;printf("Dog says: wangwang, like_eat_shit=%d\n", private_data->like_eat_shit);
}// 创建Animal实例
Animal* create_animal(int age, void (*speak_func)(void*), void* private_data) {Animal* animal = malloc(sizeof(Animal));animal->age = age;animal->speak = speak_func;animal->private_data = private_data; // 设置私有数据return animal;
}// 创建Cat实例
Animal* create_cat(int age) {CatPrivate* cat_private = malloc(sizeof(CatPrivate));cat_private->like_nothing = 1; // 设定Cat私有数据Animal* animal = create_animal(age, cat_speak, cat_private);return animal;
}// 创建Dog实例
Animal* create_dog(int age) {DogPrivate* dog_private = malloc(sizeof(DogPrivate));dog_private->like_eat_shit = 1; // 设定Dog私有数据Animal* animal = create_animal(age, dog_speak, dog_private);return animal;
}int main() {Animal* new_cat = create_cat(5);Animal* new_dog = create_dog(10);// 调用虚函数new_cat->speak(new_cat);new_dog->speak(new_dog);// 清理资源free(((CatPrivate*)new_cat->private_data));free(((DogPrivate*)new_dog->private_data));free(new_cat);free(new_dog);return 0;
}

• 继承与抽象类
    含有纯虚函数的类，我们一般称之为抽象类。抽象类不能被实例化，实例化也没有意义,唯一的好处就是代码分层

• 公共继承 私有继承 保护继承
  

• 组合优于继承?

多态

  用父类指针调用子类的成员函数
  那就是给结构体的成员变量的函数指针指向不同的函数

深浅拷贝

  浅拷贝只是对指针的拷贝，拷贝后两个指针指向同一个内存空间，
  深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针