add observer for c

Author: Jarry

observer-pattern/README.md

@@ -1,4 +1,4 @@
-# 【观察者设计模式详解】Java/JS/Go/Python/TS不同语言实现
+# 【观察者设计模式详解】C/Java/JS/Go/Python/TS不同语言实现
 
 # 简介
 观察者模式（Observer Pattern）是一种行为型模式。它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
@@ -23,7 +23,7 @@
 <img src="../docs/uml/observer-pattern.png">
 
 
-# 代码
+# Java代码
 
 ## 观察者接口
 ```java
@@ -149,5 +149,156 @@ public class ConcreteSubject extends Subject {
     concreteSubject.notify("hello, this is broadcast.");
 
 ```
+
+# Python代码
+
+## 观察者接口
+```py
+# ObserverAPI.py 观察者抽象父类，定义一些公共方法
+class ObserverAPI:
+
+    def __init__(self, name):
+        self.name = name
+
+    # 观察者发出更新通知，观察者自行监听
+    def update(self, content):
+        print(self.__class__.__name__ + '::update() [content = ' + content + ']')
+
+    def set_name(self, name):
+        self.name = name
+```
+
+## 具体观察者
+```py
+# ConcreteObserver.py 具体的观察者实现类，也可以看成订阅者，关联对应的主题类。
+# 不同的观察者也可以对应多个主题
+from src.ObserverAPI import ObserverAPI
+
+# 具体的观察者实现类，也可以看成订阅者，关联对应的主题类。
+# 不同的观察者也可以对应多个主题
+
+
+class ConcreteObserver(ObserverAPI):
+    # 给观察者绑定主题，同时把观察者添加到主题列表
+    def __init__(self, subject, name):
+        ObserverAPI.__init__(self, name)
+        
+        # python3支持的父类调用
+        # super(ConcreteObserver, self).__init__(name)
+        # super().__init__(name)
+
+        self.subject = subject
+        subject.register(self)
+
+    # 观察者发出更新通知，不用单独告诉订阅者，由订阅者自行监听
+    def update(self, content):
+        print(self.__class__.__name__ + '::update() [subject.name = ' +
+              self.subject.name + ' content = ' + content + ']')
+```
+
+```py
+# ConcreteObserver2.py 具体的观察者实现类，也可以看成订阅者，关联对应的主题类。
+# 不同的观察者可以对应不同的主题。
+from src.ObserverAPI import ObserverAPI
+
+
+# 具体的观察者实现类，也可以看成订阅者，关联对应的主题类。
+# 不同的观察者可以对应不同的主题。
+class ConcreteObserver2(ObserverAPI):
+    # 这里没有在构造器就绑定某个主题，而是从客户角度去注册观察者
+    # 观察者发出更新通知，观察者自行监听
+
+    # def update(self, content):
+    #     print(self.__class__.__name__ + '::update() [content = ' + content +']')
+    
+    pass
+```
+
+## 抽象主题类
+```py
+# Subject.py 定义抽象主题类或者接口，供具体主题类继承
+class Subject:
+
+    def __init__(self, name):
+        self.name = name
+        self.observers = []
+
+    def get_name(self):
+        return self.name
+
+    def set_name(self, name):
+        self.name = name
+
+    def register(self, observer):
+        print(self.__class__.__name__ + '::register() [observer = ' +
+              observer.__class__.__name__ + ']')
+
+        self.observers.append(observer)
+
+    def remove(self, observer):
+        self.observers.remove(observer)
+
+    # 通知由具体类来实现逻辑
+    def notify(self, name):
+        pass
+```
+
+## 具体主题类
+```py
+// ConcreteSubject.py 观察者主题类，也是发布者，重写具体的通知方法。不同主题可以关联不同的观察者。
+from src.Subject import Subject
+
+
+# 观察者主题类，也是发布者，重写具体的通知方法。不同主题可以关联不同的观察者。
+class ConcreteSubject(Subject):
+    # 不同的主题类有自己的通知方法，批量通知绑定的观察者
+    def notify(self, content):
+        print(self.__class__.__name__ + '::notify() [content = ' + content +
+              ']')
+        for observer in self.observers:
+            observer.update(content)
+```
+
+## 测试调用
+```py
+import sys
+import os
+
+os_path = os.getcwd()
+sys.path.append(os_path)
+
+from src.ConcreteSubject import ConcreteSubject
+from src.ConcreteObserver import ConcreteObserver
+from src.ConcreteObserver2 import ConcreteObserver2
+
+
+def test():
+    '''
+    * 观察者模式应用非常广泛，主要是观察者提前绑定到发布者
+    * 当发布者发布消息时，批量广播通知，而无需逐一通知
+    * 观察者监听到消息后自己决定采取哪一种行为
+    '''
+
+    # 定义一个主题，也就是发布者
+    concrete_subject = ConcreteSubject('subject1')
+    # 再声明观察者，通过构造器注册到主题上
+    observer1 = ConcreteObserver(concrete_subject, 'observer1')
+    # 也可以单独给主题注册一个新的观察者
+    observer2 = ConcreteObserver2('observer2')
+    concrete_subject.register(observer2)
+    # 可以移除观察者对象
+    # concrete_subject.remove(observer1)
+
+    # 主题开始发布新通知，各观察者自动更新
+    concrete_subject.notify('hello, this is broadcast.')
+
+
+if __name__ == '__main__':
+    print(__file__)
+    print("test start:")
+    test()
+
+```
+
 ## 更多语言版本
 不同语言实现设计模式：[https://github.com/microwind/design-pattern](https://github.com/microwind/design-pattern)

observer-pattern/c/src/concrete_observer.c

@@ -0,0 +1,25 @@
+#include "func.h"
+
+void concrete_observer_set_subject(ConcreteObserver *observer, Subject *subject)
+{
+  observer->subject = subject;
+}
+
+// 观察者发出更新通知，不用单独告诉订阅者，由订阅者自行监听
+void concrete_observer_update(ConcreteObserver *observer, char *content)
+{
+  printf("\r\n ConcreteObserver::update() [subject->name = %s content = %s]", observer->subject->name, content);
+}
+
+// 给观察者绑定主题，同时把观察者添加到主题列表
+ConcreteObserver *concrete_observer_constructor(char *name)
+{
+  printf("\r\n concrete_observer_constructor() [构建ConcreteObserver]");
+  Observer *observer = (Observer *)malloc(sizeof(Observer));
+  ConcreteObserver *concrete_observer = (ConcreteObserver *)observer;
+  strncpy(observer->name, name, 50);
+  concrete_observer->set_subject = &concrete_observer_set_subject;
+  concrete_observer->update = &concrete_observer_update;
+
+  return concrete_observer;
+}

observer-pattern/c/src/concrete_observer2.c

@@ -0,0 +1,25 @@
+#include "func.h"
+
+void concrete_observer2_set_subject(ConcreteObserver2 *observer, Subject *subject)
+{
+  observer->subject = subject;
+}
+
+// 观察者发出更新通知，不用单独告诉订阅者，由订阅者自行监听
+void concrete_observer2_update(ConcreteObserver2 *observer, char *content)
+{
+  printf("\r\n ConcreteObserver2::update() [subject->name = %s content = %s]", observer->subject->name, content);
+}
+
+// 给观察者绑定主题，同时把观察者添加到主题列表
+ConcreteObserver2 *concrete_observer2_constructor(char *name)
+{
+  printf("\r\n concrete_observer2_constructor() [构建ConcreteObserver2]");
+  Observer *observer = (Observer *)malloc(sizeof(Observer));
+  ConcreteObserver2 *concrete_observer2 = (ConcreteObserver2 *)observer;
+  strncpy(observer->name, name, 50);
+  concrete_observer2->set_subject = &concrete_observer2_set_subject;
+  concrete_observer2->update = &concrete_observer2_update;
+
+  return concrete_observer2;
+}

observer-pattern/c/src/concrete_subject.c

@@ -0,0 +1,64 @@
+#include "func.h"
+
+// 观察者主题类，也是发布者，重写具体的通知方法。不同主题可以关联不同的观察者。
+
+void concrete_registry(ConcreteSubject *subject, Observer *observer)
+{
+  printf("\r\n ConcreteSubject::register() [observer = %s]", observer->name);
+  subject->observers_length += 1;
+  Observer **new_observers = (Observer **)calloc(subject->observers_length, sizeof(Observer));
+  // 复制原有数组，并追加新内容到新数组
+  for (int i = 0; i < subject->observers_length - 1; i++)
+  {
+    new_observers[i] = subject->observers[i];
+  }
+  new_observers[subject->observers_length - 1] = observer;
+  free(subject->observers);
+  // 指向新数组
+  subject->observers = new_observers;
+}
+
+void concrete_remove(ConcreteSubject *subject, Observer *observer)
+{
+  printf("\r\n ConcreteSubject::remove() [observer = %s]", observer->name);
+  Observer **new_observers = (Observer **)calloc(subject->observers_length - 1, sizeof(Observer));
+  int new_length = 0;
+  bool is_removed = false;
+  for (int i = 0; i < subject->observers_length; i++)
+  {
+    // 过滤掉第一个出现的匹配项，达到删除目的
+    if (is_removed == false && subject->observers[i] == observer)
+    {
+      is_removed = true;
+      continue;
+    }
+    new_length++;
+    new_observers[new_length - 1] = subject->observers[i];
+  }
+  free(subject->observers);
+  // 指向新数组和新长度
+  subject->observers = new_observers;
+  subject->observers_length = new_length;
+}
+
+// 通知批量各个观察者
+void concrete_notify(ConcreteSubject *subject, char *content)
+{
+  printf("\r\n ConcreteSubject::notify() [content = %s]", content);
+  for (int i = 0; i < subject->observers_length; i++)
+  {
+    subject->observers[i]->update(subject->observers[i], content);
+  }
+}
+
+ConcreteSubject *concrete_subject_constructor(char *name)
+{
+  printf("\r\n concrete_subject_constructor() [构建订阅主题]");
+  Subject *subject = (Subject *)malloc(sizeof(Subject));
+  ConcreteSubject *concrete_subject = (ConcreteSubject *)subject;
+  strncpy(concrete_subject->name, name, 50);
+  concrete_subject->registry = &concrete_registry;
+  concrete_subject->remove = &concrete_remove;
+  concrete_subject->notify = &concrete_notify;
+  return concrete_subject;
+}

observer-pattern/c/src/func.h

@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+typedef struct Subject Subject;
+typedef struct Observer Observer;
+typedef struct ConcreteSubject ConcreteSubject;
+typedef struct ConcreteObserver ConcreteObserver;
+typedef struct ConcreteObserver2 ConcreteObserver2;
+
+// 观察者抽象父类，定义一些公共方法
+typedef struct Observer
+{
+    char name[50];
+    Subject *subject;
+    void (*set_subject)(Observer *observer, Subject *subject);
+    void (*update)(Observer *observer, char *content);
+} Observer;
+
+// 具体的观察者实现类，也可以看成订阅者，关联对应的主题类。
+typedef struct ConcreteObserver
+{
+    char name[50];
+    Subject *subject;
+    void (*set_subject)(ConcreteObserver *observer, Subject *subject);
+    void (*update)(ConcreteObserver *observer, char *content);
+} ConcreteObserver;
+ConcreteObserver *concrete_observer_constructor(char *name);
+
+// 具体的观察者实现类2，也可以看成订阅者，关联对应的主题类。
+typedef struct ConcreteObserver2
+{
+    char name[50];
+    Subject *subject;
+    void (*set_subject)(ConcreteObserver2 *observer, Subject *subject);
+    void (*update)(ConcreteObserver2 *observer, char *content);
+} ConcreteObserver2;
+ConcreteObserver2 *concrete_observer2_constructor(char *name);
+
+// 定义抽象主题类或者接口，供具体主题类继承
+typedef struct Subject
+{
+    char name[50];
+    Observer **observers;
+    int observers_length;
+    void (*registry)(Subject *subject, Observer *observer);
+    void (*remove)(Subject *subject, Observer *observer);
+    void (*notify)(Subject *subject, char *content);
+} Subject;
+
+// 观察者主题类，也是发布者，重写具体的通知方法。不同主题可以关联不同的观察者。
+typedef struct ConcreteSubject
+{
+    char name[50];
+    Observer **observers;
+    int observers_length;
+    void (*registry)(ConcreteSubject *subject, Observer *observer);
+    void (*remove)(ConcreteSubject *subject, Observer *observer);
+    void (*notify)(ConcreteSubject *subject, char *content);
+} ConcreteSubject;
+ConcreteSubject *concrete_subject_constructor(char *name);

observer-pattern/c/src/observer.c

@@ -0,0 +1,3 @@
+#include "func.h"
+
+// 观察者抽象父类，定义一些公共方法，见head文件

observer-pattern/c/src/subject.c

@@ -0,0 +1,3 @@
+#include "func.h"
+
+// 定义抽象主题类或者接口，供具体主题类继承，见head文件