C++基础——用C++实例理解UML类图

目的：学习下UML类图的创建和认识
转载于：http://blog.csdn.net/lanchunhui/article/details/49557083
类展示
基本概念及术语
可见性visibility
参数的方向parameter
direction
类成员变量或者函数的类型
类关系
关系的多重性multiplicity

类关系
assocationkonws
a
dependency
Aggregation
Composition
继承泛化
类模板

References

本文包括以下内容：
类间存在哪几种常见关系？
它们之间的区别和联系是什么？
如何在代码中反映类间的关系？
如何理解 IN/OUT mode型的参数？

类展示

class Circle
{
private:
double radius_;
Point center_;
public:
void setRadius(double _radius);
void setCenter(Point _center);
double getArea() const;
double getCircumfrence() const;
}

1
2
3
4
5
6
7
8
9
10
11


 

基本概念及术语

可见性（visibility）

‘+’ public
‘-’ private
‘#’ protected

参数的方向（parameter direction）

‘in’：用于输入的参数，get the value

‘out’：用于输出的参数， set the value

‘inout’：既可作为输入又可作为输出， get the value and set the value

这种参数形式常见于，这样一种情况，传递的是一个指针变量（如果传递的是一个既非指针，也非引用的变量，就纯做输入（in）了），既然是指针变量，便可提领指针，修改其指向的内容，既具备提供输入，又具有修改原值 的双重属性。

举例如下： 

对一个接口作如下documentation：

Prototype: ULONG GetActivationState( ULONG * pActivationState );

Parameters

Type: ULONG*
Variable: pActivationState
Mode: IN/OUT

1
2
3
4

客户端代码

ULONG activationState = 1;
ULONG result = GetActivationState(&activationState);

1
2

既然提供的是变量的地址，便可轻易地get the value 和 set the value。 所以根据

GetActivationState(ULONG*)

 参数的IN/OUT状态，推测其中的代码如下：

ULONG GetActivationState()
{
if (*activationState == 1)      // 可读属性，in
{
// TODO

// 对变量值进行修改，例如，改为0
*activationState = 0;       // 可写属性，out
}
return *activationState;
}

1
2
3
4
5
6
7
8
9
10
11
12

类成员（变量或者函数）的类型

静态成员，下划线表示
纯虚函数，斜体

类关系

Assocation (knows a)
Dependency (uses a)
Composition (has a)
Aggregation (has a)
Inheritance (is a)
Class template

关系的多重性（multiplicity）

‘0..1’， 无实例，或者1个实例
‘1’，只有一个实例
‘0..*’，
‘1..*’

类关系

assocation（konws a）

一个对象知道另一个对象的存在，该对象持有另一个对象的指针或者引用。 


 

class X
{
public:
X(Y* _ptrY):ptrY_(_ptrY) {}
void setY(Y *y) { ptrY_ = y;}
void f() { ptrY_->foo();}
private/public:
Y* ptrY_;       // X类持有Y的一个指针，可据此调用Y中的成员方法
}

1
2
3
4
5
6
7
8
9

dependency

当类Y与类X彼此独立，而类Y是类X成员函数的一个参数，或者X中成员函数的一个局部变量。 


 

class X
{
...
void f1(Y y) { ...; y.foo(); }
void f2(Y& y) { ...; y.foo(); }
void f3(Y* y) { ...; y->foo(); }
void f4() { ...; Y y; y.foo(); }
void f5() { Y::staticFoo();}
...
}

1
2
3
4
5
6
7
8
9
10

Aggregation

聚类发生的场景是：一个类是另一个类的集合或者容器，但被包含的类与容器本身并不具备相同的生命期，也就是容器销毁时，其包含的内容未必。关联（association）与聚合（aggregation）的不同之处在于，关联关系不存在一个明确的容器包含另外一个类。比如汽车和轮胎的关系，就是一种聚合关系，汽车包含着轮胎的集合，汽车的销毁，轮胎仍然可以存在。


 

class Window
{
public:
//...
private:
vectr<Shape*> ptrShapes;
}

1
2
3
4
5
6
7


 

Composition

组合（composition）是聚合（Aggregation）的增强版。组合和聚合的根本不同在于类与其所持有元素的是否具有相同的生命期，要求必须相同是一种组合关系。


 

class Circle
{

private:
...
Point center_;
...
}

1
2
3
4
5
6
7
8


 

class X
{
...
Y y;        // composition, 相同的生命期，
// 如何是引用或者指针类型，则是关联类型，是一种弱联系
Y b[10];    // 0...10, composition
}

class X
{
X() { a = new Y[10]; }
~X() { delete[] a;}
...
Y *a;       // 0...10, composition，X对象析构时，必须对a进行释放

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

继承（泛化）

类间的继承关系表达的是一种derived class B is a base class A。 


 


 

类模板

类模板意味着泛型类。 


 

template<class T>
class X
{...};

X<Y> a;

1
2
3
4
5
6

References

[1] UML Class Diagram Explained With C++ samples

[2] IN/OUT Parameters and how to work with them
in C++