C++笔记，类的创建和函数对象

1.类

    面向对象三个基本特征：封装、继承、多态。

    其实类跟结构体差不多（结构体是类的一个特定情况），只不过关键字是class。

类：具有同种属性的对象称为类，是个抽象的概念。比如说：汽车、人、狗、神；

对象：日常生活中的所有东西都是对象，是类的实例化。比如说：推土车是汽车的实例化；姚明是人的实例化；小白（狗的名字）是狗的实例化；二郎神是神的实例化；

属性：用来描述具体某个对象的特征的是属性，是静态的。比如：姚明身高2.6米多；小白的毛发是棕色的；二郎神额头上有只眼睛；

方法：每个对象有它们自己的行为或者是使用它们的方法，比如说一只狗会跑会叫等，我们把这些行为称之为方法，是动态的，可以使用这些方法来操作一个对象；

类的成员：属性和方法称为这个对象的成员，因为它们是构成一个对象的主要部分，没有了这两样东西，那么对象也没什么存在意义了。

2.声明

    不能直接在类里给变量赋初值，但是可以在类里定义一个函数，在这函数内给变量赋初值。

3.关键字

4.友元

    作用范围：整个类

    

class CP
{
private:
    void fun1()
    {
        cout << "fun1" << endl;
    }
     //不管放在哪，其范围都是整个类
    friend void fun3();
private:
    int a;
    void fun2()
    {
        cout << "fun2" << endl;
    }
}
​
void fun3()
{
    CP Cp;
    Cp.fun1();
    
    Cp.a = 1;
    Cp.fun2();
}
​
int main(void)
{
    fun3();
    system("pause");
    return 0;
}

5.抽象类和接口

    面对对象的设计，复用的重点其实应该是抽象层的复用，而不是具体某一个代码块的复用。    抽象类要被子类继承，接口要被子类实现。抽象类既可以对方法进行声明也可以对方法进行实现，接口里面只能对方法进行声明（就是在abstract class中既可以有方法的具体实现，又可以没有具体实现的抽象方法；而在interface中只能定义方法，而不能有方法的实现），这说明接口是设计的结果，抽象类是重构的结果。

     抽象类主要是用来抽象类别，接口主要是用来抽象方法功能。当你关注事物的本质的时候，请用抽象类；当你关注一种操作的时候，用接口。

    在使用方法上，如果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子都得到了这个新方法，而接口做不到这一点，如果向一个接口里加入一个新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行，这显然是接口的缺点。

     使用抽象类，那么继承这个抽象类的子类类型就比较单一，因为子类只能单继承抽象类；而子类能够同时实现多个接口，类型就比较多。接口和抽象类都可以定义对象，但是只能用他们的具体实现类来进行实例化。

    这里以JAVA举个栗子（理解两个类的区别即可，与语言无关）：

抽象类AbstractAction (JAVA)
public abstract class AbstractAction implements Action, InitializingBean {
protected final Log logger = LogFactory.getLog(getClass());
//定义方法（没有具体实现的方法）
public Event execute(RequestContext context) throws Exception;
//具体实现的方法
public void afterPropertiesSet() throws Exception {
  try {
  initAction();
  } catch (Exception ex) {
    throw new BeanInitializationException("Initialization of this Action failed: " 
    +   ex.getMessage(), ex);
  }
}
​
具体的接口Action (JAVA)
public interface Action {
  //只有定义方法（没有具体实现的方法）
  public Event execute(RequestContext context) throws Exception;
}

6.函数对象

6.1 构造函数

    在对象创建的时候调用。可以用来给类里面的变量赋初值（结构体没有此功能），无返回值。

class CStu
{
public:
  //构造函数：自动调用
  CStu() //没有返回值
  {
    age = 12;
    f = 12.12f;
  }
};
​
//也可以指定默认值
class CStu
{
public:
  CStu(int  = 12) 
  {
    age = a;
    f = 12.12f;
  }
};

    注意：成员初始化顺序只与声明的顺序有关，跟初始化列表的书写顺序无关。

6.2 析构函数

    在对象释放前的时候调用。可以用来释放new出来的内存，无返回值。

class CStu
{
public:
  ~CStu()
  {
    cout << "析构函数" << endl;
    delete pp;
  }
};

6.3 类指针this

class CStu
{
public:
  int a;
  //this不是成员，是类成员函数的隐含参数
  //this -> a 是类的a，而没写this的是局部的a
  CStu(int a)
  {
    this->a = a;   //将局部的 a 赋值给 类的a
    this->Show();
  }
  
  void Show()  
{
    cout << a << endl; 
    this->a;
  }
};

6.4 常函数

int a = 0;
class CStu
{
public:
  int a;
  void Show() const
  {
    this->a = 13;  //会报错，因为常函数里面是不允许修改数据成员的
    int b;
    b = 13;  //可以，常函数允许内部的数据修改
  }
};

6.5 static

    整型： char、short、int、long、long long。

    在类创建时，静态就已经分配好空间了 （静态的生命周期是跟整个程序共存亡的）。

    所以没创建对象时，也可以调用静态变量或函数。

    所以其没有this指针，静态函数也不能调用非静态变量。

    有个有趣的例子，不使用循环对变量自加 5 次：

#include <iostream>
using namespace std;
​
class CStu
{
public:
  static int b;
  
  CStu()//:a(2)
  {
     b++;
  }
};
​
int main()
{
  CStu st[5];  //因为每个对象都是公用静态变量，所以b++会执行五次
  system("pause");
  return 0;
}

6.6浅拷贝

class CStu
{
public:
  CStu()
  {
​
  }
​
  CStu(const CStu& a)
  {
​
  }
};
​
int main()
{
  CStu st1;
  CStu stNew(st1);  //当然也可以 CStu stNew = st1; 会更方便
  system("pause");
  return 0;
}

        在上面的代码中，stNew创建时不会调用第一个构造CStu()

    如果没有自写的拷贝构造 CStu(const CStu&a)，则默认的拷贝构造会自动把st1的值拷贝到stNew中。如果有自写拷贝构造 CStu(const CStu&a) ，则会调用此拷贝构造函数，但如果函数里什么都不写，那么stNew是不会被赋值的。

    浅拷贝所存在的问题（重复释放空间）：

class CStu
{
public:
    int *a;
    CStu()
    {
        a = new int[2];
        a[0] = 12;
        a[1] = 13;
    }
    ~CStu()
    {
        delete[] a;
    }
}
​
int main(void)
{
    {
        CStu at;
        CStu st = at;   //浅拷贝
    }//程序跑到这里后， at 和 st 都被释放
}

    因为浅拷贝是直接把 at 里的值全部拷贝到 st 里，所以 at.a 和 st.a 指针变量其实是同一内存同一地址。当 at 结束时析构函数会释放 at.a ，当st 结束时析构函数又会释放 st.a，即 a 内存释放了两次！ 

    浅拷贝只是对指针的拷贝，拷贝后两个指针指向同一个内存空间。

6.7 深拷贝

    为了解决浅拷贝的问题，深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。

    思路：在构造函数里重新申请一个空间，然后把内存贝到新的空间去（用memcpy来拷贝更方便）：

class CStu
{
public:
    int *a;
    CStu()
    {
        a = new int[2];
        a[0] = 12;
        a[1] = 13;
    }
    CStu(const CStu& b)
    {
        //申请空间
        this->a = new int[2];
        //将值拷贝到新的内存空间
        //也可以用 memcpy(this->a, b.a, 8);
        this->a[0] = b.a[0];
        this->a[1] = b.a[1];
    }
    ~CStu()
    {
        delete[] a;
    }
}
​
int main(void)
{
    {
        CStu at;
        CStu st = at;   //浅拷贝
    }//程序跑到这里后， at 和 st 都被释放
}

6.8 内联函数

    常规函数是以时间换空间，而内联函数是以空间换时间，两者用途不同，合理运用即可。

下一篇《C++笔记，类的继承》

个人公众号：拾一札记

参考资料：

C3程序猿：https://www.bilibili.com/video/BV1rW411R7g4