C++笔记(基础2)：类与对象

C++笔记(基础2)：类与对象

1. 认识类与对象

• 什么是类(class)?
  类(class)是类型(type)，是用户自定义的类型。为什么不叫它type，因为借用Simula语言中的class关键字。

• 为什么要有类？
  基于便利性的考虑，现实世界中物(object)通常被分为几种独立的分类。

• 基本概念
  

• 面向对象四大特征
  

2. 类的定义与对象创建

2.1 类的定义：与struct相似(C++)

class 类名{
     
    成员变量成员函数声明
};

class定义最后的;一定不要忘记。

• 构成
  
• 实例：复数Complex
• 作用域运算符:: – 函数归属
• 访问限定符
  

实践中，成员变量多数情况使用private或者protected,成员函数多数情况使用public。通常，通过成员函数改变对象的成员变量。

• 类定义与类实现分离
• 头文件 – 声明
  方式：#pragma once或者#ifnde...#endif
  作用：防止头文件二次编译
• 源文件 – 实现
  引用头文件：#include <>(标准库函数)/#include ""(自定义/第三方函数)

在C++书籍中为了方便.h与.cpp不做分离，但是项目开发中，需要分开。

• 强化练习：账单Bill(名称、数量、单价、小计)

• vector与string

• class与struct区别
  struct_class.cpp

#include 

using std::cout;
using std::endl;

struct SPos {
     
    int x,y,z;
};
class CPos {
     
    int x,y,z;
};
int main(){
     
#ifdef STRUCT
    SPos spos = {
     1,1,1};
    cout << "(" << spos.x << "," << spos.y << "," << spos.z << ")" << endl;
#else
    CPos cpos = {
     1,1,1};
    cout << "(" << cpos.x << "," << cpos.y << "," << cpos.z << ")" << endl;
#endif
}

C++class与struct区别是：

1. 默认的访问控制不同
   struct是public，class是private
2. struct可以使用花括号内的初始值列表{...}初始化，class不可以(C++98不可以，C++11可以)。

注意：

• C++的struct可以有成员函数，而C不可以。
• C++的struct可以使用访问控制关键字(public private protected)，而C不可以。
• C++的struct

SPos spos; // C++
struct SPos spos; // C/C++

成员变量默认初始化为随机值(主要影响指针)。

2.2 对象创建/实例化

直接创建 – 类作为类型定义变量 – 栈上创建

• 例如：

基本类型

int main(){
     
    int a = 10;
    int b(10);
    cout << a << " " << b << endl;
}

基本类型的初始化新增语法：

int a(0);// 等价 int a = 0;
const float b(1.0);// 等价 const float b = 1.0;

类类型

// 定义类
class Demo{
     };
// 创建对象
int main(){
     
    Demo d; // 变量(命名对象)
    Demo(); // 匿名对象
}

• 基本语法

类名 对象名;  // 调用默认构造函数
类名(); // 创建匿名对象

动态创建 – 堆上创建

• 例如

基本类型

int* p = new int;
delete p;
p = NULL;

类类型

// 定义类
class Demo{
     };
// 创建对象
int main(){
     
    Demo* d = new Demo;
    delete d;
    d = NULL;
}

• 基本语法

类名* 对象指针 = new 类名;// 调用默认构造函数
delete 对象指针;

对象指针new可以为对象设置初始值，例如下面代码

int* p = new int(100);
cout << *p << endl;

动态创建数组 – 堆上创建

• 例如

基本类型

int* pa = new int[10];
delete pa;// 只释放p[0]
delete [] pa;// 释放全部数组

类类型

// 定义类
class Demo{
     };
// 创建对象
int main(){
     
    Demo* d = new Demo[10];
    delete [] d;
    d = NULL;
}

对象数组指针new不可以为对象设置初始值。

int* pa = new int[10](100); // error: array 'new' cannot have initialization arguments 

注意：C++除了特殊情况，很少直接使用malloc()/free()申请释放内存，取而代之的是new/delete。

强化练习：银行与账户

空结构体与空类的大小(sizeof)为1,主要在于初始化/实例化时，编译器给变量/对象分配内存(地址)，内存最小单位为1个字节。
通常，sizeof(类型) == sizeof(变量)。

3. this指针

• 作用域:类内部
• 特点

1. 类的一个自动生成、自动隐藏的私有成员
2. 每个对象仅有一个this指针
3. 当一个对象被创建时，this指针就存放指向对象数据的首地址
4. 不是对象本身的一部分，不会影响sizeof(对象)的结果

如果成员函数形参与成员变量同名，使用this->做为前缀区分。

4. 方法

4.1 构造函数

语法

类名(参数){
     
    函数体
}

特点

• 在对象被创建时自动执行
• 构造函数的函数名与类名相同
• 没有返回值类型、也没有返回值
• 可以有多个构造函数

调用时机

• 对象直接定义创建–构造函数不能被显式调用
• new动态创建

默认构造函数
类中没有显式的定义任何构造函数，编译器就会自动为该类型生成默认构造函数，默认构造函数没有参数。

构造函数的三个作用

• 给创建的对象建立一个标识符
• 为对象数据成员开辟内存空间
• 完成对象数据成员的初始化

初始化列表

• 语法

类名(参数):成员变量(参数){
     
  函数体
}

• 作用
  初始化非静态成员变量

• 说明
  从概念上来讲，构造函数的执行可以分成两个阶段，初始化阶段和计算阶段，初始化阶段先于计算阶段。

• 必须使用初始化列表的情况

1. 常量成员，因为常量只能初始化不能赋值，所以必须放在初始化列表里面。
2. 引用类型，引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表里面。
3. 没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数初始化。

• 初始化列表与构造函数内部成员变量赋值的区别
  成员变量初始化与成员变量赋值

能使用初始化列表的时候尽量使用初始化列表

强化练习：银行管理多个账户

成员变量的初始化顺序

#include 
using std::cout;
using std::endl;
class Member1{
     
public:
    Member1(){
     
        cout << "Member1 Init" <<endl;
    }   
};
class Member2{
     
public:
    Member2(){
     
        cout << "Member2 Init" <<endl;
    }   
};
class Member3{
     
public:
    Member3(){
     
        cout << "Member3 Init" <<endl;
    }   
};
class Test{
     
public:
    Test():m3(),m2(),m1(){
     };
private:
    Member1 m1;
    Member2 m2;
    Member3 m3;
};
int main(){
     
    Test test;
}

成员变量在使用初始化列表初始化时，与构造函数中初始化成员列表的顺序无关，只与定义成员变量的顺序有关。

C++的函数可以增加默认参数。

写法：

1. 默认参数必须写在函数声明中，不能写在函数实现的参数列表中。
2. 默认参数必须写在所有非默认参数的后面。
3. 默认参数可以写任意多个。

使用：

• 默认参数可以不用传递值，此时，使用默认值。
• 默认参数可以传值，此时，使用实参值。

扩展阅读

• <> 条款4：确定对象被使用前已被初始化

4.2 析构函数

问题：银行管理多个账户的内存泄露及解决方案

语法：

~类名(){
     
    函数体
}

• 析构函数的函数名与类名相同
• 函数名前必须有一个~
• 没有参数
• 没有返回值类型、也没有返回值
• 只能有一个析构函数

调用时机

• 对象离开作用域
• delete

默认析构函数
类中没有显式的定义析构函数，编译器就会自动为该类型生成默认析构函数

作用
释放对象所申请占有的资源

RAII（资源的取得就是初始化，Resource Acquisition Is Initialization）
C++语言的一种管理资源、避免泄漏的惯用法。C++标准保证任何情况下，已构造的对象最终会销毁，即它的析构函数最终会被调用。简单的说，RAII 的做法是使用一个对象，在其构造时获取资源，在对象生命期控制对资源的访问使之始终保持有效，最后在对象析构的时候释放资源。 – 百度百科

分析下面程序执行结果：

#include 

using namespace std;

class Test{
     
public:
    Test(){
     
        cout << "Test Construct" <<endl;
    }
    ~Test(){
     
        cout << "Test Deconstruct" << endl;
    }
};

int main(){
     
    // 局部对象
    cout << "Before {" << endl;
    {
     
        cout << "After {" << endl; 
        Test t;
        cout << "Before }" << endl;
    }
    cout << "After }" << endl;

    // 动态对象
    cout << "Before {" << endl;
    {
     
        cout << "After {" << endl; 
        Test* pt = new Test;
        delete pt;
        pt = NULL;
        cout << "Before }" << endl;
    }
    cout << "After }" << endl;
    return 0;
}

问题：new/delete与malloc()与free()的区别？
new与malloc的区别

案例：MyString

4.3 引用(别名)

语法
声明：const 类型名& 对象名/类型名& 对象名
使用：与对象变量、基本类型变量一样

例如：

int a = 1
int& b = a;
cout << "&a:" << &a << endl;
cout << "&b:" << &b << endl;
b = 13;
cout << a << endl;

引用其实就是一个别名，a与b代表的是相同的对象。

何处使用引用

• 函数参数列表
• 函数返回值
• 成员变量 – 对象初始化时，必须显示初始化的变量

为何使用引用

• 避免对象复制
• 避免传递空指针
• 使用方便

类型：

• 基本类型(bool、char、int、short、float)
• 复合类型(指针、数组、引用)
• 自定义类型(struct、union、class)

引用作用：取代指针

void Func(int* n){
     
    *n = 2;
}
void Func(int& n){
     
    n = 3;
    cout << &n << endl;
}
int main(){
     
    int a =1;
    cout << &a << endl;
    Func(&a);
    cout << a << endl;
    Func(a);
    cout << a << endl;
}

函数三种传参方式

1. 传值void Func(int n)
2. 传地址/指针void Func(int* n)
3. 传引用void Func(int& n)

引用与指针的区别

• 指针指向一块内存，它的内容是所指内存的地址；引用是某块内存的别名。
• 引用只能在定义时被初始化一次，之后不可变；指针可变；
• 引用不能为空，指针可以为空；
• 引用使用时无需解引用*，指针需要解引用；
• sizeof 引用得到的是所指向的变量/对象的大小，而sizeof 指针得到的是指针本身的大小；
• 对于引用类型的成员变量，所属类的大小时按照指针大小计算，自身大小按照自身类型计算。

引用通常用于三种情形：成员变量和函数的参数列表以及函数返回值。

4.4 拷贝/复制构造函数

语法:

类名(类名& 形参){
      
    函数体
}

或者

类名(const 类名& 形参){
     
    函数体
}

调用时机
手动调用

类名 对象名;  // 调用默认构造函数
类名 对象2 = 对象1;    // 调用复制构造函数
类名 对象3(对象1);     // 调用复制构造函数

自动调用

• 一个对象作为函数参数，以值传递的方式传入函数体
• 一个对象作为函数返回值，以值从函数返回
• 一个对象拷贝构造，它的成员对象自动调用拷贝构造
• 子对象拷贝构造父对象自动拷贝构造

实践说明：

• gcc/clang自动RVO/NRVO优化，不执行拷贝构造函数。可以在编译命令添加选项禁止-fno-elide-constructors;
• VC在Debug环境下返回值执行拷贝构造函数，在Release环境下实施RVO/NRVO优化。

4.5 默认拷贝构造函数

• 本质：内存拷贝
• 作用：复制一个已经存在的对象

问题

1. 一个类可以多个拷贝构造函数吗？
2. 拷贝构造函数的参数可以不是引用吗？例如Test(Test t)
3. 如何禁用默认拷贝构造函数？在类定义，添加私有的复制构造函数的声明，但不实现。

下列程序的执行结果

#include 
#include 

using namespace std;

class Test {
     
public:
  Test() {
     }
  Test(Test &t) {
      cout << "Test(Test &t)" << endl; }
  Test(Test const &t) {
      cout << "Test(Test const &t)" << endl; }
};

int main() {
     
  Test t1;
  Test t2 = t1;
  const Test t3;
  Test t4 = t3;
}

5. 赋值运算符重载函数

语法

类名& operater=(const 类名& 形参){
     
  // 赋值操作
  return *this;
}

调用时机

• 赋值
  默认赋值运算符重载函数
• 内存拷贝
  作用
• 赋值

如何禁用默认赋值运算符重载函数？在类定义，添加私有的赋值运算符重载函数的声明，但不实现。

拷贝构造函数与赋值操作符的区别

• 拷贝构造函数：当一个已经存在的对象来初始化一个未曾存在的对象
• 赋值操作符：当两个对象都已经存在

问题下面那些是拷贝构造函数与赋值操作符？各有几次？

Demo a;   //默认构造
Demo b;  //默认构造
b = a;   / 赋值运算符重载
Demo c = a;  // 拷贝构造
Demo d = Demo(a);    // 两次拷贝构造，其中含有一次匿名对象

扩展阅读

• <>
  • 条款10：令operator=返回一个reference to *this
  • 条款11：在operator=中处理“自我赋值”
  • 条款12：复制对象时勿忘其每一个成分

6. 深拷贝(Memberwise Copy)与浅拷贝(Bitwise Copy)

• 浅拷贝：编译器默认生成的类实例间拷贝行为，对带有指针的类来说会引发 memory leak。
• 深拷贝：用户定义的行为（实质是一种构造函数）。

问题
一个类中存在指针类型的成员变量。并且类构造和析构管理指针的申请与释放。

class Demo{
     
public:
    Demo(int n){
     
        p = new int(n);
    }
    ~Demo(){
     
        delete p;
        p = NULL;
    }
private:
    int* p;
};

调用拷贝构造函数会出现什么情况？

Demo a(10);
Demo b = a;

解决

赋值运算符重载是否会有相同情况？

区别

• 浅拷贝：只拷贝指针地址
• 深拷贝：重现分配堆内存，拷贝指针指向内容

最佳实践
三大定律(Rule of three / the Law of The Big Three / The Big Three)
如果类中明确定义下列其中一个成员函数，那么必须连同其他二个成员函数编写至类内，即下列三个成员函数缺一不可:

• 析构函数（destructor）
• 复制构造函数（copy constructor）
• 复制赋值运算符（copy assignment operator）

扩展阅读

• <>
  • 条款5：了解C++默默编写并调用那些函数
  • 条款6：若不想使用编译器自动生成的函数，就该明确拒绝

7. 友元细说

作用

• 非成员函数访问类中的私有成员
  分类
• 全局友元函数：将全局函数声明成友元函数
• 友元成员函数：类的提前引用声明，将一个函数声明为多个类的友元函数
• 友元类：将整个类声明为友元

特点

• 友元关系单向性
• 友元关系不可传递

8. const限定符

8.1 本质：只读(read only)

8.2 const与变量/对象

const 类型 变量 = 初始值;
const 类型 对象;

例如：

const int size = 4;

现在比较前卫写法

类型 const 变量 = 初始值;
类型 const 对象;

例如：

int const size = 4;

• 定义时必须初始化
• 全局作用域声明的const变量默认作用域是定义所在文件
• const对象只能调用const成员函数
• const与宏定义#define的区别

8.3 const与指针

No.2 是使用最频繁的方式。

8.4 const与引用

类型 const &变量 = 初始值;与const 类型& 变量 = 初始值;都是引用对象不能改变。

8.5 const与函数的参数和返回值

• const成员变量
  • 不能在类声明中初始化const数据成员(C++11可以)
  • const成员变量只能在类构造函数的初始化列表中初始化

class 类名{
     
public:
     类名(类型 形参):成员变量(形参){
     }
private:
     const 类型 成员变量;
}

• 应用：const成员变量一般用于类定义后不可修改的信息，例如：学生学号。

注意：

1. 使用const成员变量不能省略构造函数(引用类型的成员变量相同)
2. 使用const成员变量不能使用赋值运算符重载函数

• const成员函数
  成员函数不能修改类中任何成员变量。一般写在成员函数的最后来修饰。
• 声明

class 类名{
     
public:
    返回值类型 函数名(形参列表)const;
}

• 定义

返回值类型 函数名(形参列表)const;

• 示例

#include 

using namespace std;

class Test{
     
public:
    void Print() const{
     
        cout << "Test" << endl;
    }
};

void Func(const Test& t){
     
    t.Print();
}
int main(){
     
    Test t;
    Func(t);// 变量
    Func(Test());// 匿名对象
    const Test t2;
    Func(t2); // 只读对象
    t2.Print();
}

必须在成员函数的声明和定义后都加上const

只要能够使用const,尽量使用const。

9. static限定符

本质：

• 生存周期：整个程序的生存周期。
• 作用域：属于类，不属于对象。

语法

• 声明

class 类名{
     
    static 返回类型 函数(形参列表);
};

• 定义

返回类型 类名::函数(形参列表){
     
    函数体;
}

• 调用
  • 通过类名(Class Name)调用

类名::函数(实参列表);

• 通过对象(Object)调用

对象.函数(实参列表);

规则

• static只能用于类的声明中，定义不能标示为static。
• 非静态是可以访问静态的方法和函数
• 静态成员函数可以设置private,public,protected访问权限

禁忌

• 静态成员函数不能访问非静态函数或者变量
• 静态成员函数不能使用this关键字
• 静态成员函数不能使用cv限定符(const与volatile)

因为静态成员函数是属于类而不是某个对象。

volatile是一个不常用的关键字，作用是改善编译器的优化能力。

静态成员变量

语法：

• 在类定义中声明，但是在类实现中初始化。
• 在声明时需要指定关键字static,但是在类外定义时不要指定static。
• 对象的大小不包含静态成员变量

因为静态成员变量是属于类而不是某个对象。静态成员变量所有类的对象/实例共享。

单例模式：使用静态成员变量和静态成员函数。

示例：
统计某类实例个数
习题：
下面代码输出为()[美团点评2019秋招]

#include 
using namespace std;
class Test{
     
public:
    static char x;
};
char Test::x='a';
int main(){
     
    Test exp1,exp2;
    cout<<exp1.x<<" ";
    exp1.x+=5;
    cout<<exp2.x <<endl;
}

A. f a
B. a f
C. a a
D. f f
选择b 静态成员变量是共享的

10. const static限定符

#include 

using std::cout;
using std::endl;

class StaticConstTest{
     
public:
    void print(){
     
        cout << test1 << " " << test2 << endl;
    }
private:
    static const int test1 = 1;
    static const int test2;
};

/* static */ const int StaticConstTest::test2 = 2;

int main(){
     
    StaticConstTest sct;
    sct.print();
}

注意：static const/const static成员变量在类初始化必须是数字类型。

11. 内联函数

inline – 宏定义的接班人

条件
一般用在代码比较简单的函数

语法

• 关键字inline必须与函数实现/定义体放在一起才能使函数成为内联，将inline放在函数声明前面不起任何作用
• 定义在类声明之中的成员函数将自动地成为内联函数
• 通常内联函数定义在头文件中。

慎用内联

• 如果函数体内的代码比较长，使用内联将导致内存消耗代价较高
• 如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大
• 不要随便地将构造函数和析构函数的定义体放在类声明中

本质
内联函数的代码直接替换函数调用，省去函数调用的开销

12. 运算符重载

案例：实现复数类

语法
运算符重载主要有两种方式实现：

• 成员函数运算符重载

返回值类型 operator 运算符(参数){
     
      函数体
}

• 友元函数运算符重载

friend 返回值类型 operator 运算符(形参列表) {
      
      函数体 
} 

分类

说明
1.内存运算符

• 成员函数

void *operator new(size_t size);
void *operator new[](size_t size);
void operator delete(void*p);
void operator delete [](void* p);

• 友元函数

void *operator new(类名,size_t size);
void *operator new[](类名&,size_t size);
void operator delete(类名&,void*p);
void operator delete [](类名&,void* p);

2.流运算符
流运算符只能使用友元函数实现。

inline ostream &operator << (ostream&, 类名&)
inline istream &operator >> (istream&, 类名&)

3.类型转换符
这些运算符只能使用成员函数实现。

operator char* () const;
operator int ();
operator const char () const;
operator short int () const;
operator long long () const;

4.其他运算符重载
这些运算符只能使用成员函数实现。

类名& operator = (const 类名& );
char operator [] (int i);//返回值不能作为左值
const char* operator () ();
T operator -> ();

规则

• 不能重载的运算符：成员运算符.、作用域运算符::、sizeof、条件运算符?:
• 不允许用户自定义新的运算符，只能对已有的运算符进行重载
• 重载运算符不允许改变运算符原操作数的个数
• 重载运算符不能改变运算符的优先级
• 重载运算符函数不能有默认的参数，会导致参数个数不匹配

本质
函数重载

问题

1. 为什么cout可以接收各种内置类型“对象”？因为标准库对<<做了针对各种内置类型的运算符重载。

#include 
#include 
#include 

using namespace std;

string operator+(int n,string const& str){
     
    ostringstream oss;
    oss << n << str;
    return oss.str();
}
string operator+(string const& str,int n){
     
    ostringstream oss;
    oss << str << n;
    return oss.str();
}
string operator+(float n,string const& str){
     
    ostringstream oss;
    oss << n << str;
    return oss.str();
}
string operator+(string const& str,float n){
     
    ostringstream oss;
    oss << str << n;
    return oss.str();
}
string operator+(double n,string const& str){
     
    ostringstream oss;
    oss << n << str;
    return oss.str();
}
string operator+(string const& str,double n){
     
    ostringstream oss;
    oss << str << n;
    return oss.str();
}

// 注意重载中的类型自动转换
int main(){
     
    string a = " test ";
    string res1 = "str" + a;
    cout << res1 << endl;

    auto res2 = 123 + a;
    cout << res2 << endl;
    auto res3 = a + 123;
    cout << res3 << endl;

    auto res4 = 123.456f + a;
    cout << res4 << endl;
    auto res5 = a + 123.456f;
    cout << res5 << endl;

    auto res4 = 123.456 + a;
    cout << res4 << endl;
    auto res5 = a + 123.456;
    cout << res5 << endl;
}

有如下类模板定义:[美团点评2019秋招]

class A{
     
    int n;
public:
    A(int i):n(i) {
     }
    A operator+(A b){
     
        return A(n + b.n);
    }
};

己知a, b是A的两个对象，则下列表达式中错误的是()
A. 3+a
B. a.operator+(b)
C. a+b
D. a+1
选择A（int + a）int调用的是默认的+，默认的+不能与对象a相加运算