add proxy for c

Jarry · Jarry · commit 8a8670b4c1ba · 2023-04-24T17:20:24.000+08:00
diff --git a/prototype-pattern/README.md b/prototype-pattern/README.md
@@ -212,7 +212,8 @@ public class Application {
 
 ## 基础原型抽象类
 
-```func.h 基础头文件
+```c
+// func.h 基础头文件
 #include <stdio.h>
 #include <ctype.h>
 #include <stdlib.h>
diff --git a/proxy-pattern/README.md b/proxy-pattern/README.md
@@ -1,4 +1,4 @@
-# 【代理设计模式详解】Java/JS/Go/Python/TS不同语言实现
+# 【代理设计模式详解】C/Java/JS/Go/Python/TS不同语言实现
 
 # 简介
 代理模式（Proxy Pattern）是一种结构型设计模式，用一个类来代理另一个类或几个类的功能。
@@ -22,7 +22,7 @@
 <img src="../docs/uml/proxy-pattern.png">
 
 
-# 代码
+# Java代码
 
 ## 代理接口类
 ```java
@@ -98,5 +98,152 @@ public class RealImage implements Image {
     // 再调用一次，不会重复实例化
     image.display();
 ```
+
+# Go代码
+
+## 代理接口类
+```go
+// Image.go 定义一个接口供代理和实际调用来使用
+type Image interface {
+  Init(fileName string)
+  Display()
+}
+
+```
+
+## 功能代理类
+```go
+// ProxyImage.go 代理类也实现了基础接口
+type ProxyImage struct {
+  fileName string
+  // 直接聚合真实类
+  // realImage RealImage
+  // 聚合接口
+  realImage Image
+}
+
+// 设置文件名称
+func (p *ProxyImage) SetFileName(fileName string) {
+  p.fileName = fileName
+}
+
+func (p *ProxyImage) Display() {
+  fmt.Println("ProxyImage::Display() " + p.fileName)
+  if p.realImage == nil {
+    p.realImage = &RealImage{}
+    p.realImage.Init(p.fileName)
+  }
+  // 代理类调用真实类的方法
+  p.realImage.Display()
+}
+
+```
+
+## 真实功能类
+```go
+// RealImage.go 真实类也实现基础代理接口
+type RealImage struct {
+  fileName string
+}
+
+// 在初始化时执行内部逻辑
+func (r *RealImage) Init(fileName string) {
+  r.fileName = fileName
+  r.LoadFromDisk(fileName)
+}
+
+func (r *RealImage) Display() {
+  fmt.Println("RealImage::Display() " + r.fileName)
+}
+
+// 这个方法只是内部使用
+func (r *RealImage) LoadFromDisk(fileName string) {
+  fmt.Println("RealImage::LoadFromDisk()  " + fileName)
+}
+```
+
+## 测试调用
+```go
+func main() {
+  fmt.Println("test start:")
+  /**
+   * 代理模式就是用一个类来代理另一个类或几个类的功能，以便隔绝外部客户和内部真实类
+   * 这样真实类和调用方之间有一个代理屏障，保证了安全
+   * 同时真实的类如果初始化过，就不再初始化，提升了性能
+   */
+
+  // 声明代理类来执行真实类的能力
+  var image = &src.ProxyImage{}
+  image.SetFileName("001.jpg")
+
+  // 代理类执行真实类的能力
+  image.Display()
+
+  // 再调用一次，真实类不会重复实例化
+  image.Display()
+}
+```
+
+# C代码简版
+```c 
+// simple_proxy.c
+#include <stdio.h>
+
+// 代理模式就是用一个类来代理另一个类或几个类的功能，以便隔绝外部客户和内部真实类
+
+// 定义接口
+typedef struct Interface
+{
+    void (*method)(struct Interface *interface);
+} Interface;
+
+// 实现接口的具体类
+typedef struct Concrete
+{
+    void (*method)(struct Concrete *interface);
+} Concrete;
+
+void real_method(struct Concrete *interface)
+{
+    printf("调用真实方法 real_method.\n");
+}
+
+// 代理类，继承接口，聚合具体类实例
+typedef struct Proxy
+{
+    struct Interface *real_subject;
+} Proxy;
+
+// 代理类方法实现，通过聚合的具体类实例来调用具体类的方法
+void proxy_method(struct Interface *interface)
+{
+    struct Proxy *p = (struct Proxy *)interface;
+    p->real_subject->method((struct Interface *)p);
+}
+
+int main()
+{
+    // 创建具体类实例
+    struct Concrete real_subject = {
+        .method = &real_method,
+    };
+
+    // 创建代理类实例并聚合具体类实例
+    struct Proxy proxy_instance = {
+        .real_subject = (struct Interface *)&real_subject,
+    };
+
+    // 将代理类的方法指针指向代理类的方法实现
+    struct Interface proxy_interface = {
+        .method = &proxy_method,
+    };
+
+    // 通过代理类的接口调用具体类方法
+    proxy_interface.method((struct Interface *)&proxy_instance);
+
+    return 0;
+}
+
+```
 ## 更多语言版本
 不同语言实现设计模式：[https://github.com/microwind/design-pattern](https://github.com/microwind/design-pattern)
diff --git a/proxy-pattern/c/src/func.h b/proxy-pattern/c/src/func.h
@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+typedef struct Image Image;
+typedef struct ProxyImage ProxyImage;
+typedef struct RealImage RealImage;
+
+// 定义一个接口供代理和实际调用来使用
+typedef struct Image
+{
+    char file_name[200];
+    RealImage *real_image;
+    void (*set_file_name)(Image *image, char *file_name);
+    void (*display)(Image *image);
+} Images;
+
+void image_set_file_name(Image *image, char *file_name);
+
+// 代理类也实现了基础接口
+typedef struct ProxyImage
+{
+    char file_name[200];
+    // 代理类聚合真实类
+    RealImage *real_image;
+    void (*set_file_name)(ProxyImage *image, char *file_name);
+    void (*display)(ProxyImage *image);
+} ProxyImage;
+ProxyImage *proxy_image_constructor(char *file_name);
+
+// 真实类实现基础接口
+typedef struct RealImage
+{
+    char file_name[200];
+    RealImage *real_image;
+    void (*set_file_name)(RealImage *image, char *file_name);
+    void (*display)(RealImage *image);
+} RealImage;
+RealImage *real_image_constructor(char *file_name);
+void real_image_init(RealImage *image, char *file_name);
diff --git a/proxy-pattern/c/src/image.c b/proxy-pattern/c/src/image.c
@@ -0,0 +1,9 @@
+#include "func.h"
+
+// 基础接口，供代理类和真实类实现，定义在head
+
+// 设置文件名称
+void image_set_file_name(Image *image, char *file_name)
+{
+  strcpy(image->file_name, file_name);
+}
diff --git a/proxy-pattern/c/src/proxy_image.c b/proxy-pattern/c/src/proxy_image.c
@@ -0,0 +1,26 @@
+#include "func.h"
+
+// 代理类实现了基础接口
+
+void proxy_image_display(ProxyImage *image)
+{
+  printf("\r\n ProxyImage::display() [file_name=%s]", image->file_name);
+  if (image->real_image == NULL)
+  {
+    image->real_image = real_image_constructor(image->file_name);
+    real_image_init(image->real_image, image->file_name);
+  }
+  // 代理类调用真实类的display
+  image->real_image->display(image->real_image);
+}
+
+ProxyImage *proxy_image_constructor(char *file_name)
+{
+  printf("\r\n proxy_image_constructor() [构建ProxyImage]");
+  Image *image = (Image *)malloc(sizeof(Image));
+  strcpy(image->file_name, file_name);
+  image->set_file_name = &image_set_file_name;
+  ProxyImage *proxy_image = (ProxyImage *)image;
+  proxy_image->display = &proxy_image_display;
+  return proxy_image;
+}
diff --git a/proxy-pattern/c/src/real_image.c b/proxy-pattern/c/src/real_image.c
@@ -0,0 +1,33 @@
+#include "func.h"
+
+// 真实类实现基础接口
+
+// 这个方法只是内部使用
+void real_image_load_from_disk(RealImage *image, char *file_name)
+{
+  printf("\r\n RealImage::load_from_disk() [file_name=%s]", file_name);
+}
+
+// 在初始化时执行内部逻辑
+void real_image_init(RealImage *image, char *file_name)
+{
+  strcpy(image->file_name, file_name);
+  real_image_load_from_disk(image, file_name);
+}
+
+void real_image_display(RealImage *image)
+{
+  printf("\r\n RealImage::display() [file_name=%s]", image->file_name);
+}
+
+RealImage *real_image_constructor(char *file_name)
+{
+  printf("\r\n real_image_constructor() [构建RealImage]");
+  Image *image = (Image *)malloc(sizeof(Image));
+  strcpy(image->file_name, file_name);
+  image->set_file_name = &image_set_file_name;
+  RealImage *real_image = (RealImage *)image;
+  real_image->real_image = NULL;
+  real_image->display = &real_image_display;
+  return real_image;
+}
diff --git a/proxy-pattern/c/test/simple_proxy.c b/proxy-pattern/c/test/simple_proxy.c
@@ -0,0 +1,56 @@
+#include <stdio.h>
+
+// 代理模式就是用一个类来代理另一个类或几个类的功能，以便隔绝外部客户和内部真实类
+
+// 定义接口
+typedef struct Interface
+{
+    void (*method)(struct Interface *interface);
+} Interface;
+
+// 实现接口的具体类
+typedef struct Concrete
+{
+    void (*method)(struct Concrete *interface);
+} Concrete;
+
+void real_method(struct Concrete *interface)
+{
+    printf("调用真实方法 real_method.\n");
+}
+
+// 代理类，继承接口，聚合具体类实例
+typedef struct Proxy
+{
+    struct Interface *real_subject;
+} Proxy;
+
+// 代理类方法实现，通过聚合的具体类实例来调用具体类的方法
+void proxy_method(struct Interface *interface)
+{
+    struct Proxy *p = (struct Proxy *)interface;
+    p->real_subject->method((struct Interface *)p);
+}
+
+int main()
+{
+    // 创建具体类实例
+    struct Concrete real_subject = {
+        .method = &real_method,
+    };
+
+    // 创建代理类实例并聚合具体类实例
+    struct Proxy proxy_instance = {
+        .real_subject = (struct Interface *)&real_subject,
+    };
+
+    // 将代理类的方法指针指向代理类的方法实现
+    struct Interface proxy_interface = {
+        .method = &proxy_method,
+    };
+
+    // 通过代理类的接口调用具体类方法
+    proxy_interface.method((struct Interface *)&proxy_instance);
+
+    return 0;
+}
diff --git a/proxy-pattern/c/test/test.c b/proxy-pattern/c/test/test.c
@@ -0,0 +1,35 @@
+#include "../src/func.h"
+
+int main(void)
+{
+  printf("test start:\r\n");
+  /**
+   * 代理模式就是用一个类来代理另一个类或几个类的功能，以便隔绝外部客户和内部真实类
+   * 这样真实类和调用方之间有一个代理屏障，保证了安全
+   * 同时真实的类如果初始化过，就不再初始化，提升了性能
+   */
+
+  // 声明代理类来执行真实类的能力
+  Image *image = (Image *)proxy_image_constructor("abc.png");
+  image->set_file_name(image, "001.jpg");
+
+  // 代理类执行真实类的能力
+  image->display(image);
+
+  // 再调用一次，不会重复实例化
+  image->display(image);
+}
+
+/**
+jarry@jarrys-MacBook-Pro c % gcc test/test.c ./src下*.c
+jarry@jarrys-MacBook-Pro c % ./a.out
+test start:
+
+ proxy_image_constructor() [构建ProxyImage]
+ ProxyImage::display() [file_name=001.jpg]
+ real_image_constructor() [构建RealImage]
+ RealImage::load_from_disk() [file_name=001.jpg]
+ RealImage::display() [file_name=001.jpg]
+ ProxyImage::display() [file_name=001.jpg]
+ RealImage::display() [file_name=001.jpg]% 
+ */
diff --git a/proxy-pattern/go/test/test.go b/proxy-pattern/go/test/test.go
