C++基础知识复习

此笔记为准备面试用，主要是自己学过的一些知识概念。主要如下：

重载和重写的关系区别             overloading & overwrite

重载运算符使用                        overloading 

类的继承，私有成员变量         Inheritance, encapsulation, private members

以之前读过的nest_simulator的C++源码为学习实例。

class Node
{
  friend class NodeManager;
  friend class Subnet;
  friend class proxynode;
  friend class Synapse;
  friend class Model;
  friend class SimulationManager;

  Node& operator=( const Node& ); //!< not implemented

public:
  Node();
  Node( Node const& );
  virtual ~Node();

  /**
   * Virtual copy constructor.
   * This function should create a new object by
   * calling the derived class' copy constructor and
   * return its pointer.
   */
  virtual Node*
  clone() const
  {
    return 0;
  }

首先可以看到在这个类下定义了很多友元类，友元类的定义可以让Node类直接访问这些类的私有成员变量和方法。然后是一句运算符的重载。

运算符重载

Node& operator = (const Node& );

这里的重载使用显然是用于拷贝构造的。这里的“&”表示引用返回，引用返回的应用我也不甚了解，比较典型的是在自增运算符的重载例子里见到的。

Test& Test::operator++()
{
    m_value++;    //先增量
    return *this;  //返回当前对象
}

 Test Test::operator++(int)
{
    Test temp(*this);  //创建临时对象
    m_value++;       //再增量
    return temp;      //返回临时对象
}

然后在搞ACM的时候我常用到的是优先队列时和使用矩阵快速幂时的重载。

struct point{
    int x;
    int y;
    int times;
    friend bool operator < (point a, point b)
    {
        return a.times > b.times;    //重载小于号使得小的先出队列    
    }
}; 

这样可以使元素在队列里自动按需要的属性排序。这里的含义有点怪，因为想要point按times来升序排列，这个“<”重载的含义就是如果a.times > b.times，则a在队列中的优先度就小于b。

矩阵快速幂模板如下：

struct matrix{
    int m[N][N];
};
matrix operator * (matrix, matrix);//重载声明
matrix operator ^ (matrix a, int b){
    matrix ans;
    for (int i=0;i<N;i++){
        for (int j=0;j<N;j++) ans.m[i][j] = (i==j);
    }
    while (!b){
        if (b&1) ans = ans*a;
        a = a*a;
        b>>=1;
    }
    return ans;
}

matrix operator * (const matrix a, const matrix b){
    matrix ans;
    for (int i=0;i<N;i++){
        for (int j=0;j<N;j++){
            ans.m[i][j] =0;
        }
    }
    for (int i=0;i<N;i++){
        for (int j=0;j<N;j++){
            for (int k=0;k<N;k++){
                ans.m[i][j] += a.m[i][k]*b.m[k][j];
            }
        }
    }
    return ans;
}

虚基类

回到之前代码，下一句是这样的：

virtual ~Node();

累了，先更到这儿~