类和类之间的关系

类和类之间的关系

• Object Oriented Programming

• Object Oriented Design

面向对象的思想:类与类之间产生关系

关系:

• Inheritance -> 继承

• Composition -> 复合

• Delegation -> 委托 -> Composition by reference -> 两个类之间用指针相连

复合(composition)

示例代码:

#pragma once
#ifndef __ADAPTER__
#define __ADAPTER__
​
template<class T>
class queue
{
protected:
    deque<T> c; // 底层容器,这就是复合的概念
public:
    bool empty() const { return c.empty(); }
    size_type size() const { return c.size(); }
    T front() { return c.front(); }
    T back() { return c.back(); }
​
    void push(const value_type& x) { c.push_back(x); }
    void pop() { c.pop_front(); }
};
​
#endif // !__ADAPTER__

复合的概念:

queue这个类中有一个其他的类deque<T> -> queue当中全部调用deque的方法去实现功能

adapter适配.可能在deque当中开放了100个功能.写一个queue复合了deque,但是只开放了六个接口.

复合概念下的构造函数和析构函数

• 构造由内而外

示例代码:

// Container类当中复合一个Component类
Container::Container(...) : Component() {...}; // 这是正确的写法.只是在构造这一步编译器会帮我们去做这个事情

默认调用的是无参数构造函数,需要调用其他的构造函数需要手动编写修改

• 析构由外而内

示例代码:

Container::~Container(...) {... ~Component()};

Composition by reference

A类当中包含着B类的指针:

#pragma once
​
// 防卫式声明
#ifndef __STRING__
#define __STRING__
​
#include <string.h>
​
// 头文件定义
class StringRep;
class String
{
public:
    // 设计构造函数 -> 这里只是定义了函数接口.并没有实现
    String(const char* cstr = 0);
    String(const String& str); // 接收自己为参数,所以是拷贝构造
    String& operator=(const String& str); // s2 = s1,作用的是s2,那么s2就要先自毁,自毁完了以后在创建一个和s1一样大的内存空间进行拷贝
    ~String(); // 析构函数 -> 当类死亡的时候(离开他的作用域)析构函数就会被调用
private:
    StringRep* rep;
};
​
#endif // !__STRING__

StringRep类

#pragma once
#ifndef __STRINGREP__
#define __STRINGREP__
​
#include "string.h"
namespace {
    class StringRep
    {
        friend class String;
        StringRep(const char* s);
        ~StringRep();
        int count;
        char* rep;
    };
}
​
#endif // !_STRINGREP__

Inheritance(继承)

继承语法:

#pragma once
#ifndef __NODE__
#define __NODE__
​
struct _List_node_base
{
    _List_node_base* _M_next;
    _List_node_base* _M_prev;
};
​
template<typename _Tp>
// : public _List_node_base为继承的语法
struct _List_node : public _List_node_base
{
    _Tp _M_data;
};
​
#endif // !__NODE__

这里的构造函数和析构函数和复合的情况一样

• 构造函数先调用父类.然后才用自己的构造函数

• 析构函数先调用自己的,然后再调用父类的构造函数

•