高内聚与低耦合实现小记
总所周知，实际软件开发中要实现高内聚、低耦合的设计原则。c语言和c++不同，c语言面向过程、c++面向对象。
真正的项目中。要对业务升级。原来的业务函数须要保留，要保证老的功能继续维持，不能直接删除。这时候
c语言面向过程，通常使用回调的方法。
c++面向对象，要实现高内聚、低耦合，须要使用接口技术。
C语言为例：
软件通常有后台日志的记录功能。用log函数实现，主业务用business函数表示：
void log()
{
printf("Logging...\n");
}void business()
{
while(1)
{
sleep(1);
printf("Deal Business...\n");
log();
}
}int main()
{
business();
return 0;
}如今须要对后台日志功能进行升级。该怎样实现？
一般人的想法是这样：再写一个函数log2。然后business中log改为log2，这样不就能够了？
可是你想想，主业务代码怎能轻易修改？由于一个小小的功能而要改变基本的业务代码，这样不是显得智商非常捉急？
换一种思路，使用回调：
#include <stdio.h>
#include <unistd.h>
void log1()
{
printf("1 Logging...\n");
}
void log2()
{
printf("2 Logging...\n");
}
void business( void (*f)() )
{
while(1)
{
sleep(1);
printf("Deal Business...\n");
f();
}
}
int main()
{
business(log1);
return 0;
}
business函数接受一个函数指针。该指针指向的函数没有參数，返回值为void，符合log函数的原型。
business中仅仅要f()就可以调用对应的函数。
当须要使用log1时，向business传log1、要使用升级后的log2时。传入log2就可以。
C++为例：
C++中强调面向对象的思想。
#include <iostream>
using namespace std;
class Log
{
public:
void log()
{
cout << "logging..." << endl;
}
};
class Business
{
private:
Log *l;
public:
Business(Log *l = NULL)
{}
void business()
{
while(1)
{
sleep(1);
cout << "Deal Business..." << endl;
l->log();
}
}
};
int main()
{
Business b(new Log);
b.business();
return 0;
}如今。我们须要对后台日志功能升级，怎么做？有人想到了C++中的重载。在Log类中重载一个函数log2；
也有人想到了继承Log类。覆写log函数等等，可是这几种方法，都须要对Business类中的代码进行变动。怎样解决呢？于是C++中的接口技术就派上用处了。
记住。接口强调的是方法，接口里的方法定义为纯虚函数，接口不能实例化、也不须要实例化，须要接口里的功能的类仅仅须要继承该接口就可以！以下给出演示样例：
#include <iostream>
using namespace std;
class Log
{
public:
virtual void log() = 0;//纯虚函数
};
class Log1 : public Log//继承接口
{
public:
void log()
{
cout << "1 logging..." << endl;
}
};
class Log2 : public Log//继承接口
{
public:
void log()
{
cout << "2 logging..." << endl;
}
};
class Business
{
public:
void business(Log * f)//函数參数仅仅要Log指针，详细传入的是Log1还是Log2的实例。由多态进行实现
{
while(1)
{
sleep(1);
cout << "Deal Business..." << endl;
f->log();
}
}
};
int main()
{
Business b;
b.business(new Log2);//会调用Log2类中的log日志函数！
return 0;
}
此时，对日志业务升级就不会影响business的代码了，仅仅需将不同的日志实例化传入business中就可以。
这是一种非常棒的设计思想。
