C 设计模式实践教程
设计模式是软件工程中的一种重要概念，它提供了一系列可重用的解决方案，用于解决在软件设计过程中常见的问题。在C语言中，设计模式可以帮助开发者编写更加模块化、可扩展和可维护的代码。本教程将围绕C语言，通过实践来介绍几种常见的设计模式。
目录
1. 单例模式（Singleton）
2. 工厂模式（Factory Method）
3. 抽象工厂模式（Abstract Factory）
4. 建造者模式（Builder）
5. 适配器模式（Adapter）
6. 装饰者模式（Decorator）
7. 代理模式（Proxy）
8. 观察者模式（Observer）
9. 状态模式（State）
10. 策略模式（Strategy）
11. 模板方法模式（Template Method）
12. 迭代器模式（Iterator）
13. 组合模式（Composite）
1. 单例模式（Singleton）
单例模式确保一个类只有一个实例，并提供一个全局访问点。
csharp
public class Singleton
{
private static Singleton instance;
private Singleton() { }
public static Singleton GetInstance()
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
}
2. 工厂模式（Factory Method）
工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。
csharp
public interface IProduct
{
void Use();
}
public class ConcreteProductA : IProduct
{
public void Use()
{
Console.WriteLine("Using Product A");
}
}
public class ConcreteProductB : IProduct
{
public void Use()
{
Console.WriteLine("Using Product B");
}
}
public class Creator
{
public IProduct FactoryMethod()
{
return new ConcreteProductA();
}
}
3. 抽象工厂模式（Abstract Factory）
抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
csharp
public interface IProductA
{
void Use();
}
public interface IProductB
{
void Use();
}
public class ConcreteProductA : IProductA
{
public void Use()
{
Console.WriteLine("Using Product A");
}
}
public class ConcreteProductB : IProductB
{
public void Use()
{
Console.WriteLine("Using Product B");
}
}
public interface IFactory
{
IProductA CreateProductA();
IProductB CreateProductB();
}
public class ConcreteFactory : IFactory
{
public IProductA CreateProductA()
{
return new ConcreteProductA();
}
public IProductB CreateProductB()
{
return new ConcreteProductB();
}
}
4. 建造者模式（Builder）
建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
csharp
public class Product
{
public string PartA { get; set; }
public string PartB { get; set; }
}
public class Builder
{
public Product Product { get; private set; }
public Builder()
{
Product = new Product();
}
public Builder AddPartA(string partA)
{
Product.PartA = partA;
return this;
}
public Builder AddPartB(string partB)
{
Product.PartB = partB;
return this;
}
public Product Build()
{
return Product;
}
}
5. 适配器模式（Adapter）
适配器模式允许将一个类的接口转换成客户期望的另一个接口，适配器让原本接口不兼容的类可以合作无间。
csharp
public interface ITarget
{
void Request();
}
public class Adaptee
{
public void SpecificRequest()
{
Console.WriteLine("SpecificRequest");
}
}
public class Adapter : ITarget
{
private Adaptee adaptee;
public Adapter(Adaptee adaptee)
{
this.adaptee = adaptee;
}
public void Request()
{
adaptee.SpecificRequest();
}
}
6. 装饰者模式（Decorator）
装饰者模式动态地给一个对象添加一些额外的职责，就增加功能来说，装饰者模式比生成子类更为灵活。
csharp
public interface IComponent
{
void Operation();
}
public class ConcreteComponent : IComponent
{
public void Operation()
{
Console.WriteLine("ConcreteComponent's Operation");
}
}
public class Decorator : IComponent
{
protected IComponent component;
public Decorator(IComponent component)
{
this.component = component;
}
public void Operation()
{
component.Operation();
}
}
public class ConcreteDecoratorA : Decorator
{
public ConcreteDecoratorA(IComponent component)
: base(component)
{
}
public override void Operation()
{
base.Operation();
AddBehavior();
}
private void AddBehavior()
{
Console.WriteLine("ConcreteDecoratorA's Behavior");
}
}
7. 代理模式（Proxy）
代理模式为其他对象提供一种代理以控制对这个对象的访问。
csharp
public interface IImage
{
void Display();
}
public class RealImage : IImage
{
private string fileName;
public RealImage(string fileName)
{
this.fileName = fileName;
LoadFromDisk();
}
public void Display()
{
Console.WriteLine("Displaying " + fileName);
}
private void LoadFromDisk()
{
Console.WriteLine("Loading " + fileName + " from disk");
}
}
public class ProxyImage : IImage
{
private RealImage realImage;
private string fileName;
public ProxyImage(string fileName)
{
this.fileName = fileName;
}
public void Display()
{
if (realImage == null)
{
realImage = new RealImage(fileName);
}
realImage.Display();
}
}
8. 观察者模式（Observer）
观察者模式定义对象间的一对多依赖关系，当一个对象改变状态，所有依赖于它的对象都会得到通知并自动更新。
csharp
public interface IObserver
{
void Update();
}
public class ConcreteObserver : IObserver
{
public void Update()
{
Console.WriteLine("Observer got notified!");
}
}
public interface ISubject
{
void RegisterObserver(IObserver observer);
void RemoveObserver(IObserver observer);
void NotifyObservers();
}
public class ConcreteSubject : ISubject
{
private List observers = new List();
public void RegisterObserver(IObserver observer)
{
observers.Add(observer);
}
public void RemoveObserver(IObserver observer)
{
observers.Remove(observer);
}
public void NotifyObservers()
{
foreach (var observer in observers)
{
observer.Update();
}
}
}
9. 状态模式（State）
状态模式允许一个对象在其内部状态改变时改变它的行为。
csharp
public interface IState
{
void Handle();
}
public class ConcreteStateA : IState
{
public void Handle()
{
Console.WriteLine("State A");
}
}
public class ConcreteStateB : IState
{
public void Handle()
{
Console.WriteLine("State B");
}
}
public class Context
{
private IState state;
public Context(IState state)
{
this.state = state;
}
public void Request()
{
state.Handle();
}
public void SetState(IState state)
{
this.state = state;
}
}
10. 策略模式（Strategy）
策略模式定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。
csharp
public interface IStrategy
{
int Execute(int a, int b);
}
public class ConcreteStrategyA : IStrategy
{
public int Execute(int a, int b)
{
return a + b;
}
}
public class ConcreteStrategyB : IStrategy
{
public int Execute(int a, int b)
{
return a - b;
}
}
public class Context
{
private IStrategy strategy;
public Context(IStrategy strategy)
{
this.strategy = strategy;
}
public int ExecuteStrategy(int a, int b)
{
return strategy.Execute(a, b);
}
}
11. 模板方法模式（Template Method）
模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
csharp
public abstract class AbstractClass
{
public abstract void Operation1();
public abstract void Operation2();
public void TemplateMethod()
{
Operation1();
Operation2();
}
}
public class ConcreteClassA : AbstractClass
{
public override void Operation1()
{
Console.WriteLine("ConcreteClassA's Operation1");
}
public override void Operation2()
{
Console.WriteLine("ConcreteClassA's Operation2");
}
}
12. 迭代器模式（Iterator）
迭代器模式提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
csharp
public interface IIterator
{
object First();
object Next();
bool IsDone();
object CurrentItem();
}
public class ConcreteIterator : IIterator
{
private List _list;
private int _current = 0;
public ConcreteIterator(List list)
{
_list = list;
}
public object First()
{
_current = 0;
return _list[_current];
}
public object Next()
{
_current++;
if (_current = _list.Count;
}
public object CurrentItem()
{
return _list[_current];
}
}
13. 组合模式（Composite）
组合模式将对象组合成树形结构以表示“部分-整体”的层次结构。
csharp
public abstract class Component
{
public abstract void Operation();
}
public class Leaf : Component
{
public override void Operation()
{
Console.WriteLine("Leaf operation");
}
}
public class Composite : Component
{
private List _children = new List();
public void Add(Component child)
{
_children.Add(child);
}
public void Remove(Component child)
{
_children.Remove(child);
}
public override void Operation()
{
foreach (var child in _children)
{
child.Operation();
}
}
}
以上是C语言中几种常见设计模式的实践教程。通过这些模式，开发者可以更好地组织代码，提高代码的可读性和可维护性。在实际开发中，可以根据具体需求选择合适的设计模式，以提高软件的质量。
Comments NOTHING