C++：复习笔记2

2021-03-08 本文已影响0人重庆八怪

class complex
{
 public:
   double real() const
   {return this->re;}//this 可写可不写
private:
   double re,im;

}

complex c1,c2

cout<<c1.real(); //complex::real(&c1)
cout<<c2.real(); //complex::read(&c2)

static 类成员元素
多个object只有一份数据
static 类成员函数
静态函数没有this指针，只用于访问静态成员元素

class Account {
public：
  static double m_rate;
  static void set_rate(const double& x) {m_rate = x ;}
};

double Account::m_rate = 8.0

int main(){
  Account::set_rate(5.0);//class name调用
  
  Account a;
  a.set_rate(7.0);//通过object调用

}

单例 singleton

class A {
public:
  static A& getInstance(){static A a;return a;}
  setup(){...}
private:
  A();
  A(const A& rhs);
}

class template

template<typename T>
class complex
{
public:
  complex(T r=0,T i=0)
    : re(r),im(i)
  {}
  complex& operator += (const complex&)
  T real() const{return re;}
  T imag() const{return im;}
private:
  T re,im;
  
  friend complex& __doapl(complex*,const complex&); 
}

{
 complex<double> c1(1.0,2.0);

}

funcation template

template <class T> //typename关键之是一样的
inline
const T& min(const T& a, const T& b)
{
  return b<a?b:a;//如果不是内建类型，这里需要用到类的操作符重载小于符号
}

函数模板不需要明确指出类型，会做argument deduction(实参推到)

namespace
主要用于避免多个同名的类函数等同名

a.cpp                b.cpp
namespace std    namespace std
{                 {
  ..                ...
}                 }

可以写到多个文件里面

#inlcude<iostream.h>
using namespace std; //using directive

int main()
{
  cin<<..;
  cout<<..;
return 0
}

#include<iostream.h>
using std::out  //using declaration

int main()
{
  std::cin<<...;
  cout<<...;
retun 0
}

operator type() const
explicit
template specialization

inheritance(继承)
composition(复合)
delegation(委托)

composition(复合) has-a
queue |--->deque

Adapter 适配器

template<class T>
class queue{ //Adapter 适配器 deque 功能已经很强大，queue只需要开放其中一部分功能
...
protected:
  deque<T> c; //底层容器
public:
  //以下完全利用c的操作函数完成
  bool empty() const{return c.empty();}
  size_type size() const {return c.size();}
  reference fron(){return c.front();}
  //
  void push(const value_type&x){c.push_back(x);}
  void pop(){c.pop_front();}
}

composition(符合)下的构造和析构

container|--->component

构造由内而外

container的够着函数首先调用component的default够着函数
然后才执行自己的。

Container::Container(...):component(){...};
                         ————————————
                         这部分是编译器
                         自己加的

析构由外到内

container的析构函数首先执行自己，然后才调用component的
析构函数。

container::~container{..~component()};
                        ———————————
                        编辑以自己加
                        的

delegation(委托).composition by reference

class string{
public：
    string();
    string(const char* s);
    string(const string& s);
    string &operator=(const string& s);
    ~string();
...
private:
   stringRep* rep;//pimpl 委托指针
}

string --->stringrep

inheritance(继承),is-a

struct _List_node_base
{
  _List_node_base* _M_next;
  _List_node_base* _M_prev;
};

template<typename _Tp>
struct _List_node: public _List_node_base
{
 _Tp _M_data;
};


__List_node_base
     /\
     |
     |
 _List_node

inheritance(继承)关系下的的构造和析构

 base    --->基类的析构函数必须是virtual，       
  /\
  |
  |
derived

构造由内而外

derived的构造函数首先调用base的default构造函数
然后执行自己

derived::derived(...):base(){....};

析构函数由外到内

derived的析构函数先执行，然后调用base的析构函数。
注意要写virtual

derived::derived(...){...~base()};

虚函数和多态

inheritance with vritual funcations

no-virtual函数：你不希望derived class重新定义(override)它
vitural函数：你希望derived class重新定义(overriade，重写)它，它已经有自己的定义
pure virtual函数：你希望derived class 一定要重写它(overrade),没有默认定义

class shape{
public：
  virtual void draw() const=0;
  virtual void error(const std::string& msg);
  int objectid() const;
  ...
}

Template method 非常重要

cdocument::serialize为一个纯虚函数

cdocument::
onfileopen()
{
  ...
  serialize()
  ...
}

class cmydoc:public cdocument
{
 virtual serialize(){...}
}

main()
{
 cmydoc mydoc;
 mydoc.onfileopen()

}

实际测试代码：

#include<iostream>
#include<stdio.h>
#include<stdlib.h>

using namespace std;

class base
{
public:
  virtual void base_1() const
  {
   cout<<"in base"<<endl;
  }
  void process() const
  {
    cout<<"test in base begin"<<endl;
    base_1();//框架写好了，子函数实现
    cout<<"test in base end"<<endl;
  }
};




class myclass:public base
{
public:
  void base_1() const //virtual 可写可不写
  {
    cout<<"in myclass"<<endl;
  }

};



int main()
{
 //method 1:template method
 //base_1方法子类做了重新定义
 myclass my; //定义一个子类对象
 my.process();//实际上做this->process 然后this->base_1,vptr指针
  
 //method 2:父类指针指向子类对象
 base* test = &my; 
 test->base_1();
 
 //父类自己的实现
 base mybase;
 mybase.process();
 
}

结果为：
test in base begin
in myclass
test in base end
in myclass
test in base begin
in base
test in base end

component+inheritnce

 base(1)
  |
  |
derived(3) |--->component(2)
构造谁再前？已经标号

 base(2) |--->component(1)
   |
   |
derived(3)

构造谁再前？已经标号

观察者 delegation + inheritance

         n
subject---->observer
               |
               |
            具体的obs

class subject
{
  int m_value;
  vetor<observer*>m_views;
  public:
  void attach(observer* obs)
  {
   m_views.push_back(obs);
  }
  
  void set_val(int value)
  {
    m_value=value;
    notify();
  }
  void notify()
  {
    for(int i=0;i<m_view.size();++i)
            m_view[i]->update(this,m_value);  
  }  
}

class observer
{
public:
 virtual void update(subject* sub,int value) = 0;
}

const 函数，指定this中的对象不能更改

#include<iostream>
#include<stdio.h>
#include<stdlib.h>

using namespace std;


class base{
public:
  int* p;
  base():p(NULL)
  {}
  ~base()
  {
    free(p);
  }

};



class test{
  public:
    base* p;
    const int   t;
    test():t(1)
    {
     p = new base();

    }
    void change() const
    {

     (this->p)->p = new int(4); //只要不改变this->p的值即可，指向对象的值可以更改
     cout<<*((this->p)->p)<<endl;
    }
    ~test()
   {
    delete p;
   }

};


int main()
{
  test a;
  a.change();
  base b;
}

C++：复习笔记2

猜你喜欢

热点阅读