C++基础2：类与对象

最新推荐文章于 2022-07-07 18:02:28 发布

jdzhangxin

最新推荐文章于 2022-07-07 18:02:28 发布

阅读量462

点赞数

本文链接：https://blog.csdn.net/jdzhangxin/article/details/79053074

版权

C++基础2：类与对象

1. 认识类与对象

基本概念

概念	比喻
对象/实例	楼房
实例化	建造
类	建筑图纸

* 面向对象四大特征

特征	说明	类比
抽象	抽出具体事物的普遍性的本质	分门别类：鸟类、哺乳类、鱼类
封装	把数据与处理(函数)包在一起	通信录(增加、删除)
继承	数据与处理(函数)的传承	财富与绝技、混血儿(肤色/头发、两种语言
多态	同一个事物(函数)的多种形态	手机键盘数字与字母、电脑键盘功能键

2. 类的定义与对象创建

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

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

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

构成

构成	作用
数据成员(data member)/成员变量/属性	对象内部数据和状态，只能在类定义中声明，可以在成员函数中直接调用。
成员函数/方法	对象相关的操作，可以在类内实现或类外实现。

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

限定符	作用
`private`[默认]	私有
`public`	公开
`protected`	保护

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

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

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

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

class与struct区别
struct_class.cpp

#include <iostream>

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
}

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

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

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

2.2 对象创建/实例化

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

例如：

// 定义类
class Demo{};
// 创建对象
int main(){
    Demo d;
    Demo();
}

基本语法

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

动态创建 – 堆上创建

例如：

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

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

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

基本语法

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

动态创建数组 – 堆上创建

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

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

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

实例：账单

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

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

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

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

3. `this`指针

作用域 – 类内部
特点
- 类的一个自动生成、自动隐藏的私有成员
- 每个对象仅有一个this指针
- 当一个对象被创建时，this指针就存放指向对象数据的首地址
- 不是对象本身的一部分，不会影响sizeof(对象)的结果

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

4. 方法

4.1 构造函数

语法

类名(参数){
    函数体
}

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

调用时机

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

默认构造函数

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

构造函数的三个作用

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

初始化列表

语法

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

作用

初始化非静态成员变量

说明

从概念上来讲，构造函数的执行可以分成两个阶段，初始化阶段和计算阶段，初始化阶段先于计算阶段。
* 必须使用初始化列表的情况
1.常量成员，因为常量只能初始化不能赋值，所以必须放在初始化列表里面。
2.引用类型，引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表里面。
3.没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数初始化。
* 初始化列表与构造函数内部成员变量赋值的区别
成员变量初始化与成员变量赋值

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

成员变量的初始化顺序

#include <iostream>
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.2 析构函数

语法：

~类名(){
    函数体
}

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

调用时机

对象离开作用域
delete

默认析构函数

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

作用

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

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

4.3 引用(别名)

语法

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

何处使用引用

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

为何使用引用

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

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

引用作用：取代指针

引用与指针的区别

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

引用通常用于两种情形：成员变量和函数的参数列表。

4.4 拷贝/复制构造函数

语法:

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

或者

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

或者

类名(const 类名 形参){
    函数体std:swap();
}

调用时机

手动调用

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

自动调用
* 一个对象作为函数参数，以值传递的方式传入函数体
* 一个对象作为函数返回值，以值从函数返回
* 一个对象用于给另外一个对象进行初始化(赋值初始化)

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

4.5 默认拷贝构造函数

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

如何禁用默认拷贝构造函数？在类定义，添加私有的复制构造函数的声明，但不实现。

5. 赋值运算符重载函数

语法

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

调用时机

赋值

默认赋值运算符重载函数

内存拷贝

作用

赋值

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

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

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

Demo a;
Demo b;
b = a;
Demo c = a;
Demo d = Demo(a);

6. 深拷贝与浅拷贝

问题

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

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）

7. 友元细说

作用

非成员函数访问类中的私有成员

特点

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

8. `const`限定符

本质：不可修改
const与变量/对象

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

例如：

const int size = 4;

现在比较前卫写法

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

例如：

int const size = 4;

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

`const`	宏定义`#define`
编译器处理方式	编译运行阶段使用
类型	有具体的类型
安全检查	编译阶段会执行类型检查
存储方式	分配内存

* const与指针

No.	类型	语法	作用
1	`const`指针	`类型* const 变量 = 初始值;`	指针指向地址不能改变
2	指向`const`对象的指针	`const 类型* 变量 = 初始值;` `类型 const* 变量 = 初始值;`	指针指向对象不能改变
3	指向`const`对象的`const`指针	`const 类型* const 变量 = 初始值;`	指针指向地址和对象不能改变

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

const与引用

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

const与函数的参数和返回值

类型	语法	作用	说明
`const`参数	`返回值类型函数(const 类型形参)`	函数内部不能改变参数的值	这样的参数的输入值
`const`返回值	`const 返回值类型函数(形参列表)`	函数的返回值不能改变	常用于字符串/指针

* const成员变量
* 不能在类声明中初始化const数据成员
* const成员变量只能在类构造函数的初始化列表中初始化

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

如果使用const成员变量不能使用赋值运算符重载函数

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

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

定义

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

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

const修饰位置	作用
变量	变量不可修改，通常用来替代`#define`
对象/实例	对象的成员变量不可修改，只能调用`const`成员函数
函数参数	参数不能在函数内部修改，只作为入参
函数返回值	返回的结果不能被修改，常用于字符串
成员变量	只能在初始化列表中初始化
成员函数	不改变成员变量

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

9. `static`限定符

本质：

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

语法

声明

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

定义

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

调用

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

规则

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

禁忌

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

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

静态成员变量

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

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

`static`修饰位置	作用
变量	静态变量
函数	只源文件内部使用的函数
成员变量	对象共享变量
成员函数	类提供的函数，或者作为静态成员对象的接口

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

10. `const static`限定符

#include <iostream>

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();
}

变量类型	声明位置
一般成员变量	在构造函数初始化列表中初始化
`const`成员常量	必须在构造函数初始化列表中初始化
`static`成员变量	必须在类外初始化
`static const`/`const static`成员变量	变量声明处或者类外初始化

注意：static const/const static成员变量必须是整形。

11. 内联函数

inline – 宏定义的接班人

条件

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

语法

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

慎用内联

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

本质

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

12. 运算符重载

案例：实现复数类

语法

运算符重载主要有两种方式实现：
* 成员函数运算符重载

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

友元函数运算符重载

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

分类

No.	类型	运算符	成员函数	友元函数
1	双目算术运算符	`+` `-` `*` `/` `%`	`类名 operator 运算符(const 类名&) const`	`类名 operator 运算符(const 类名&, const 类名&)`
2	关系运算符	`==` `!=` `>` `>=` `<` `<=`	`bool operator 运算符 (const 类名& ) const`	`bool operator 运算符 (const 类名&,const 类名&)`
3	双目逻辑运算符	`&&` `¦¦`	`bool operator 运算符 (const 类名& ) const`	`bool operator 运算符 (const 类名&,const 类名&)`
4	单目逻辑运算符	`!`	`bool operator !() const`	`bool operator ! (const 类名&)`
5	单目算术运算符	`+` `-`	`类名& operator 运算符 ()`	`类名& operator 运算符 (const 类名&)`
6	双目位运算符	`&` `¦`	`类名 operator 运算符 (const 类名& ) const`	`类名 operator 运算符 (const 类名& ,const 类名& )`
7	单目位运算符	`~`	`类名 operator ~ ()`	`类名 operator ~ (类名&)`
8	位移运算符	`<<` `>>`	`类名 operator 运算符 (int i) const`	`类名 operator 运算符 (const 类名&,int i)`
9	前缀自增减运算符	`++` `--`	`类名& operator 操作符 ()`	`类名& operator 操作符 (类名&)`
10	后缀自增减运算符	`++` `--`	`类名 operator ++ (int)`	`类名 operator ++ (类名&,int)`
11	复合赋值运算符	`+=` `-=` `*=` `/=` `%=` `&=` `¦=` `^=`	`类名& operator 运算符 (const 类名& )`	`类名& operator += (类名&,const 类名&)`
12	内存运算符	`new` `delete`	参见说明	参见说明
13	流运算符	`>>` `<<`	-	参见说明
14	类型转换符	`数据类型`	参见说明	-
15	其他运算符重载	`=` `[]` `()` `->`	参见说明	-

说明

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、条件运算符?:
不允许用户自定义新的运算符，只能对已有的运算符进行重载
重载运算符不允许改变运算符原操作数的个数
重载运算符不能改变运算符的优先级
重载运算符函数不能有默认的参数，会导致参数个数不匹配

本质

函数重载

#include <iostream>
#include <algorithm>
#include <sstream>

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;
}

jdzhangxin

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
C++基础2：类与对象

C++基础2：类与对象1. 认识类与对象基本概念概念比喻对象/实例楼房实例化建造类建筑图纸* 面向对象四大特征特征说明类比抽象抽出具体事物的普遍性的本质分门别类：鸟类、哺乳类、鱼类封装把数据与处理(函数)包在一起通信录(增加、删除)
复制链接

扫一扫