C++进阶语法——OOP（面向对象编程）【C++深度学习部署（四）】

已于 2024-04-17 12:07:27 修改
阅读量883 收藏 6
点赞数 2
分类专栏： C++ 文章标签： c++
于 2023-10-27 22:37:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23022733/article/details/133932495
版权

文章目录

1、C++ OOP面向对象开发

1.1 类（classes）和对象（objects）

简单介绍一下类：

  • C++ 类（classes）
    • 创建对象用的蓝图（blueprint）
    • ⽤户⾃定义的数据类型
    • 有成员属性（data）和成员⽅法（methods）
    • 可以隐藏属性和⽅法（private）
    • 可以提供公共接口（public）
    • 示例： Account, Student, std::vector, std::string

简单介绍一下对象：

  • C++ 对象（objects）：
    • 由类创建而来
    • 表示类的⼀个具体的实例（Instance）
    • 可以有很多个实例，每个都有独立的身份
    • 每个对象都可以使⽤类中定义的⽅法
  • Account对象示例：
    • Jobs、Alice 的account是Account类的实例
    • 每个实例都有它的余额、可以提现、存钱

虽然 int 不是类，这里把它看成一个类，int 后面的 high_score 和 low_score 可以看成 int 类实例化后的对象；
创建 Account 类后，实例化2个对象，分别是：jobs_account 和 alice_account；
std是类，后面跟着的容器 vector 和字符串 string 是对象；

如下图所示，

在这里插入图片描述

A、声明一个类：

在这里插入图片描述

B、创建类的对象：

还可以根据类创建一个指针，并且在堆上使用关键字 new 动态分配内存空间，使用后再用 delete 删除释放内存空间，

在这里插入图片描述

一旦有了类的对象，就可以像 C++ 其他变量去使用

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Account
{
    // 属性
    string name {"None"};
    double balance {0.0};

    // 方法
    bool deposit(double amount); // 存款
    bool withdraw(double amount); // 取款
};

int main()
{
    Account jobs_account;  // 初始化属性
    Account alice_account;  // 初始化属性

    Account accounts [] {jobs_account, alice_account}; // 数组

    vector<Account> accounts_vec {jobs_account}; // vector
    accounts_vec.push_back(alice_account);

    Account *p_account = new Account(); // 指针
    delete p_account;

    return 0;
}

C、获取类的属性或方法：

使用点操作符：

在这里插入图片描述

如果是⼀个指向对象的指针，可以解引用或者使⽤箭头操作符，
需要注意： 使用 . 操作符的时候需要在前面加一个括号 () ，因为 . 操作符的优先级高于 * 解引用运算符的优先级，

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Account
{
public:    
    // 属性
    string name {"None"};
    double balance {0.0};

    // 方法
    bool deposit(double amount){
        balance += amount;
        cout << name << "刚存入" << amount << "元，现在余额为" << balance << "元" << endl;
        return true;
    }; // 存款
    bool withdraw(double amount){
        if (balance >= amount){
            balance -= amount;
            cout << name << "刚取出" << amount << "元，现在余额为" << balance << "元" << endl;
            return true;
        } else {
            cout << name << "余额不足，取款失败" << endl;
            return false;
        }
    }; // 取款
};

int main()
{
    Account jobs_account;
    jobs_account.name = "Jobs";
    jobs_account.balance = 1000.0;

    jobs_account.deposit(500.0);

    Account *alice_account = new Account();
    (*alice_account).name = "Alice";
    alice_account->balance = 2000.0;

    (*alice_account).deposit(1000.0);
    alice_account->withdraw(500.0);

    return 0;
}

输出：

Jobs刚存入500元，现在余额为1500元
Alice刚存入1000元，现在余额为3000元
Alice刚取出500元，现在余额为2500元
1.2 public、private、protected访问权限
  • public
    • 可以被任何实体访问
  • private
    • 只能被本类的⽅法访问
  • protected
    • 可以被本类和子类（继承）的⽅法访问

在这里插入图片描述

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Account
{
private:    
    // 属性
    string name {"None"};
    double balance {0.0};

public:
    // 方法
    bool deposit(double amount){
        balance += amount;
        cout << name << "刚存入" << amount << "元，现在余额为" << balance << "元" << endl;
        return true;
    }; // 存款
    bool withdraw(double amount){
        if (balance >= amount){
            balance -= amount;
            cout << name << "刚取出" << amount << "元，现在余额为" << balance << "元" << endl;
            return true;
        } else {
            cout << name << "余额不足，取款失败" << endl;
            return false;
        }
    }; // 取款
};

int main()
{
    Account jobs_account;
    // jobs_account.name = "Jobs";  // 报错
    // jobs_account.balance = 1000.0;  // 报错

    // cout << jobs_account.name << "的余额为" << jobs_account.balance << "元" << endl;  // 报错

    jobs_account.deposit(500.0);

    return 0;
}

输出：

None刚存入500元，现在余额为500元
1.3 实现成员方法

在类中定义成员方法，适用于代码量较少的程序，

在这里插入图片描述

在类外面定义成员方法，适用于代码量较大的程序，

在这里插入图片描述

代码：

编译器无法区分 set_name 函数是类内的函数还是其他函数，所以在 set_name 前面添加类名::，表示这是类的成员函数，

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Account
{
private:
    // 属性
    string name {"None"};
    double balance {0.0};

public:
    // 方法

    // 设置余额
    void set_balance(double amount){balance = amount;};
    // 获取余额
    double get_balance(){return balance;};

    // 设置名称
    void set_name(string name);
    // 获取名称
    string get_name();

    // 存款
    bool deposit(double amount);
    // 取款
    bool withdraw(double amount);
};

void Account::set_name(string name){
    this->name = name; // this指针指向当前对象
}
string Account::get_name(){
    return name;
}
bool Account::deposit(double amount){
    balance += amount;
    cout << name << "刚存入" << amount << "元，现在余额为" << balance << "元" << endl;
    return true;
}
bool Account::withdraw(double amount){
    if (balance >= amount){
        balance -= amount;
        cout << name << "刚取出" << amount << "元，现在余额为" << balance << "元" << endl;
        return true;
    } else {
        cout << name << "余额不足，取款失败" << endl;
        return false;
    }
}

int main()
{
    Account alice_account;
    alice_account.set_name("Alice's account"); // 设置名称
    alice_account.set_balance(1000.0); // 设置余额

    cout << alice_account.get_name() << "的余额为" << alice_account.get_balance() << "元" << endl;

    alice_account.deposit(200.0);
    alice_account.withdraw(500.0);
    alice_account.withdraw(1500.0);

    return 0;
}

输出：

Alice's account的余额为1000元
Alice's account刚存入200元，现在余额为1200元
Alice's account刚取出500元，现在余额为700元
Alice's account余额不足，取款失败

上面的代码看着比较繁杂，我们可以用头文件和源文件编写。
为了防止头文件被多次导入造成一些冲突，一般添加如下语句，关于头文件被多次导入造成一些冲突可参考这个链接：CSDN链接，例如创建 Account.h 头文件：

#ifndef ACCOUNT_H
#define ACCOUNT_H
#endif // ACCOUNT_H

整个 Account.h 头文件代码如下，一般不在头文件写 using namespace std;，一般显式地使用 std:string，

#ifndef ACCOUNT_H
#define ACCOUNT_H
#include <string>

class Account
{
private:
    // 属性
    std::string name {"None"};
    double balance {0.0};

public:
    // 方法

    // 设置余额
    void set_balance(double amount){balance = amount;};
    // 获取余额
    double get_balance(){return balance;};

    // 设置名称
    void set_name(std::string name);
    // 获取名称
    std::string get_name();

    // 存款
    bool deposit(double amount);
    // 取款
    bool withdraw(double amount);
};

#endif // ACCOUNT_H

然后再根据头文件编写类的成员方法的定义，因为已经引入了头文件#include "Account.h"，所以不需要再写 #include <string>，这里也是显示地引入 std::cout，std::endl，

#include "Account.h"
#include <iostream>

void Account::set_name(std::string name){
    this->name = name; // this指针指向当前对象
}
std::string Account::get_name(){
    return name;
}
bool Account::deposit(double amount){
    balance += amount;
    std::cout << name << "刚存入" << amount << "元，现在余额为" << balance << "元" << std::endl;
    return true;
}
bool Account::withdraw(double amount){
    if (balance >= amount){
        balance -= amount;
        std::cout << name << "刚取出" << amount << "元，现在余额为" << balance << "元" << std::endl;
        return true;
    } else {
        std::cout << name << "余额不足，取款失败" << std::endl;
        return false;
    }
}

最后是程序的 main.cpp 文件，直接编译 main.cpp 即可，

#include <iostream>
#include <string>
#include <vector>
#include "Account.h" // 引入头文件

using namespace std;


int main()
{
    Account alice_account;
    alice_account.set_name("Alice's account"); // 设置名称
    alice_account.set_balance(1000.0); // 设置余额

    cout << alice_account.get_name() << "的余额为" << alice_account.get_balance() << "元" << endl;

    alice_account.deposit(200.0);
    alice_account.withdraw(500.0);
    alice_account.withdraw(1500.0);

    return 0;
}

输出：

Alice's account的余额为1000元
Alice's account刚存入200元，现在余额为1200元
Alice's account刚取出500元，现在余额为700元
Alice's account余额不足，取款失败
1.4 构造函数（constructor）和 析构函数（destructor）
1.4.1 构造函数（constructor）
  • 特殊的成员
  • 对象创建的时候自动调用
  • 适⽤于实例参数初始化
  • 函数名和类的名称⼀致
  • 无需设置返回类型
  • 可以被重载（overload）
1.4.2 析构函数（destructor）
  • 特殊的成员⽅法
  • 函数名和类的名称⼀致，前⾯跟着⼀个 ~ 波浪符号
  • 对象销毁的时候自动调用
  • 没有参数，没有返回类型
  • 只有一个析构函数（不能重载）
  • 适用于释放内存等资源

如果不手动创建构造函数和析构函数，那么C++会自动帮助创建构造函数和析构函数，只不过都是空的，

构造函数（constructor）和析构函数（destructor）：

在这里插入图片描述

构造函数在栈上创建，当程序运行结束时，他们各自的析构函数会被调用，所以会调用4次析构函数，

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Account
{
private:
    // 属性
    std::string name {"account"};
    double balance {0.0};
public:
    void setName(string name){ this->name = name;}; // 设置名称
    // 构造函数
    Account(){
        cout << "没有参数的构造函数被调用" << endl;
    };
    Account(std::string name){
        cout << "带string name参数的构造函数被调用" << endl;
    };
    Account(double balance){ 
        cout << "带double balance参数的构造函数被调用" << endl;
    };
    Account(string name, double balance){ 
        cout << "带string name和double balance参数的构造函数被调用" << endl;
    };
    // 析构函数
    ~Account(){ 
        cout << name << " 的析构函数被调用" << endl;
    };
};


int main()
{
    // 用{}表示作用域，{}内的程序运行后会调用析构函数
    {
        Account alice_account;
        alice_account.setName("Alice's account"); // 设置名称
    }
    // 出栈顺序：后入先出
    {
        Account jobs_account;
        jobs_account.setName("Jobs's account"); 

        Account bill_account("Bill's account");
        bill_account.setName("Bill's account"); 

        Account steve_account(1000.0);
        steve_account.setName("Steve's account"); 
    }

    Account *mark_account = new Account("Mark's account", 1000.0);
    mark_account->setName("Mark's account");
    delete mark_account;

    return 0;
}

输出：

没有参数的构造函数被调用
Alice's account 的析构函数被调用
没有参数的构造函数被调用
带string name参数的构造函数被调用
带double balance参数的构造函数被调用
Steve's account 的析构函数被调用
Bill's account 的析构函数被调用
Jobs's account 的析构函数被调用
带string name和double balance参数的构造函数被调用
Mark's account 的析构函数被调用

构造函数初始化列表：

:name {name} 中，冒号后面的 name 类成员属性的 name，{ } 里面的 name 是函数的形参 name，

在这里插入图片描述

代码1（构造函数内部初始化参数）：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Account
{
private:
    // 属性
    std::string name {"account"};
    double balance {0.0};
public:
    // 打印信息
    void printInfo();
    // 构造函数，初始化参数
    Account(string name, double balance);
   
};

void Account::printInfo(){
    cout << "name: " << name << ", balance: " << balance << endl;
}
// 构造函数内部初始化参数
Account::Account(string name, double balance){
    this->name = name;
    this->balance = balance;
}

int main()
{

    Account *mark_account = new Account("Mark's account", 1000.0);
    mark_account->printInfo(); // 打印信息
    delete mark_account;

    return 0;
}

输出：

name: Mark's account, balance: 1000

代码2（初始化列表初始化参数）：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Account
{
private:
    // 属性
    std::string name {"account"};
    double balance {0.0};
public:
    // 打印信息
    void printInfo();
    // 构造函数，初始化参数
    Account();
    Account(string name);
    Account(string name, double balance);
   
};

void Account::printInfo(){
    cout << "name: " << name << ", balance: " << balance << endl;
}

// 构造函数内部初始化参数
// Account::Account(){
//     name = "None";
//     balance = 0.0;
// }
// Account ::Account(string name){
//     this->name = name;
//     balance = 0.0;
// }
// Account::Account(string name, double balance){
//     this->name = name;
//     this->balance = balance;
// }

// 构造函数初始化列表
Account::Account()
    :name{"none"}, balance{0.0}{
        
    }
Account::Account(string name)
    :name{name}, balance{0.0}{
        
    }

Account::Account(string name, double balance)
    :name{name}, balance{balance}{
        
    }

int main()
{
    Account alice_account;
    alice_account.printInfo(); // 打印信息

    Account jobs_account {"Jobs's account"};
    jobs_account.printInfo(); 

    Account bill_account {"Bill's account", 1000.0};
    bill_account.printInfo(); 

    return 0;
}

输出：

name: none, balance: 0
name: Jobs's account, balance: 0
name: Bill's account, balance: 1000
1.5 代理构造函数（delegating constructor）
  • 重载的构造函数很相似
  • 冗余的代码可能会导致错误
  • C++ 允许使⽤代理构造函数
    • 在⼀个构造函数初始化列表中调⽤另⼀个构造函数，被调用的构造函数需要包含其他构造函数的参数，

代码： 建议使用 debug 查看程序运行过程

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Account
{
private:
    // 属性
    std::string name {"account"};
    double balance {0.0};
public:
    // 打印信息
    void printInfo();
    // 构造函数，初始化参数
    Account();
    Account(string name);
    Account(string name, double balance);
   
};

void Account::printInfo(){
    cout << "name: " << name << ", balance: " << balance << endl;
}

// 构造函数初始化列表
Account::Account()
    :Account {"none",0}{
        
    }
Account::Account(string name)
    :Account {name, 0}{
        
    }

Account::Account(string name, double balance)
    :name{name}, balance{balance}{
        
    }

int main()
{
    Account alice_account;
    alice_account.printInfo(); // 打印信息

    Account jobs_account {"Jobs's account"};
    jobs_account.printInfo(); 

    Account bill_account {"Bill's account", 1000.0};
    bill_account.printInfo(); 

    return 0;
}

输出：

name: none, balance: 0
name: Jobs's account, balance: 0
name: Bill's account, balance: 1000
1.6 拷贝构造函数（copy constructor）
  • 当对象被拷贝时，C++必须从已存在的对象复制出⼀个新的对象，
  • 何时使⽤拷贝构造函数？
    • 对象以值传递的方式传递给函数的参数（作参数）
    • 函数以值方式返回对象
    • 使用已存在的对象复制新的对象
  • 如果不提供自己写的copy constructor，编译器会⾃动⽣成⼀个（可能不符合要求），如果是指针，拷贝的是地址，所以编译器自动生成的拷贝构造函数是浅拷贝，可能在析构函数释放资源时会报错，

A、拷贝构造函数——值传递

在这里插入图片描述

B、拷贝构造函数——以值方式返回

以值方式返回拷贝构造函数返回的 an_account 副本

在这里插入图片描述

C、拷贝构造函数——使用已存在的对象复制新的对象

在这里插入图片描述

D、拷贝构造函数的声明

  • 首先拷⻉构造函数也是构造函数，所以函数的名称和类的名称一样，函数的参数列表只有一个参数，那就是对象，是使用引用的方式传递的，
  • 为什么使用引用和const？
    • 因为如果不使用引用，而是使用值传递的方式传递，又需要拷贝一份，这本来就是拷贝构造函数干的事情，就会陷入永无止境的递归了，
    • 使用const是不想对引用的对象进行改动，

在这里插入图片描述

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Account
{
private:
    // 属性
    string name {"account"};
    double balance {0.0};
public:
    string getName() {return name;} // 获取name
    double getBalance() {return balance;} // 获取balance
    // 构造函数
    Account(string name = "none", double balance = 0.0);
    // 析构函数
    ~Account();
    // 拷贝构造函数
    Account(const Account &source);
};

Account::Account(string name, double balance)
    :name {name}, balance {balance}
    {
        cout << "2个参数的构造函数被调用，name：" << name << endl;
    }

Account::~Account()
{
    cout << "析构函数被调用，name：" << name << endl;
}

// 拷贝构造函数：根据已存在对象的属性来更新新对象的属性（name,balance）
Account::Account(const Account &source)
    :name {source.name}, balance {source.balance} // 初始化列表
    {
        cout << "拷贝构造函数被调用，是" << source.name << "的拷贝" << endl;
    }
// 打印账户信息
void printAccountInfo(Account acc)
{
    cout << acc.getName() << "的余额是：" << acc.getBalance() << endl;
}
int main()
{
    // 1.值传递的方式给函数传递参数
    // Account alice_account;
    // printAccountInfo(alice_account);
    
    // 2.基于已存在的对象创建新的对象
    Account alice_account {"Alice's account", 1000.0};
    Account new_account {alice_account}; // 拷贝构造函数被调用
    return 0;
}

输出：

2个参数的构造函数被调用，name：Alice's account
拷贝构造函数被调用，是Alice's account的拷贝
析构函数被调用，name：Alice's account
析构函数被调用，name：Alice's account
1.7 浅拷贝（shallow copy）和深拷贝（deep copy）
  • 如果不提供自己写的copy constructor，编译器会⽣成默认的
  • 将⽬标对象的值逐个拷⻉过来；
  • 如果是指针，拷贝的是值（即指针变量的值，是指向的地址），⽽不是指向的对象（指向的对象称为浅拷贝）
    • 在析构函数中释放内存时，其他对象中的指针可能还在指向被释放的资源，在析构函数释放内存资源时可能会报错，例如下面的代码，如果使用编译器默认的拷贝构造函数，在进行析构函数释放内存资源时可能会报错

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Account
{
private:
    // 属性
    string name {"account"};
    double *balance {nullptr};
public:
    double get_balance() {return *balance;}; // 获取余额
    string get_name() {return name;}; // 获取名字

    // 构造函数
    Account(string name = "none", double balance = 0.0); // 有默认参数的构造函数
    // 拷贝构造函数
    Account(const Account &source);
    // 析构函数
    ~Account();

    
};
Account::Account(string name, double balance)
    {
        this->name = name;
        this->balance = new double {balance}; // 堆上分配内存
        cout << "2个参数的构造函数被调用，name: " << name << endl;
    }
    
// 拷贝构造函数    
Account::Account(const Account &source)
    :Account {source.name, *source.balance} // 代理构造函数
    {
        cout << "拷贝构造函数被调用，是" << source.name << "的拷贝" << endl;
    } 
    
Account::~Account(){
    if (balance != nullptr)
        delete balance; // 释放内存
    cout << "析构函数被调用，name: " << name << endl;
}

int main()
{
    // 演示浅拷贝和深拷贝
    Account alice_account {"Alice", 1000.0};
    Account new_account {alice_account}; // 拷贝构造函数被调用
    // cout << new_account.get_balance() << endl; // 1000.0
    return 0;
}

如果使用编译器默认的拷贝构造函数，在进行 alice_account 析构函数释放内存时会报错，如下图，

在这里插入图片描述

1.7.1 浅拷贝（shallow copy）

如下图，alice_account 浅拷贝到 new_account，编译器会默认创建一个拷贝构造函数，它是逐个元素按值拷贝的，如果是指针，则是拷贝的地址。当调用析构函数的时候，由于后进先出的原则，new_account 上的地址被释放后，alice_account 的地址也会被释放，但地址已经被释放，所以会造成堆空间重复释放的问题，导致程序报错，

在这里插入图片描述

编译器默认生成的拷贝构造函数如下：

在这里插入图片描述

1.7.2 深拷贝（deep copy）

在函数内部，在堆上分配一个新的 double 类型的内存空间，初始化为1000，并且把新的内存空间给1000，

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Account
{
private:
    // 属性
    string name {"account"};
    double *balance {nullptr};
public:
    double get_balance() {return *balance;}; // 获取余额
    string get_name() {return name;}; // 获取名字

    // 构造函数
    Account(string name = "none", double balance = 0.0); // 有默认参数的构造函数
    // 拷贝构造函数
    Account(const Account &source);
    // 析构函数
    ~Account();

    
};
Account::Account(string name, double balance)
    {
        this->name = name;
        this->balance = new double {balance}; // 堆上分配内存
        cout << "2个参数的构造函数被调用，name: " << name << endl;
    }
// 拷贝构造函数    
Account::Account(const Account &source)
    :Account {source.name, *source.balance} // 代理构造函数，深拷贝
    {
    	// this->name = source.name;
    	// this->balance = source.balance  // 浅拷贝
        // this->balance = new double {*source.balance}; // 深拷贝
        cout << "拷贝构造函数被调用，是" << source.name << "的拷贝" << endl;
    } 
    
Account::~Account(){
    if (balance != nullptr)
        delete balance; // 释放内存
    cout << "析构函数被调用，name: " << name << endl;
}

int main()
{
    // 演示浅拷贝和深拷贝
    Account alice_account {"Alice", 1000.0};
    Account new_account {alice_account}; // 拷贝构造函数被调用
    // cout << new_account.get_balance() << endl; // 1000.0
    return 0;
}

输出：

2个参数的构造函数被调用，name: Alice
2个参数的构造函数被调用，name: Alice
拷贝构造函数被调用，是Alice的拷贝
析构函数被调用，name: Alice
析构函数被调用，name: Alice
1.8 在类中使用const
  • 常函数
    • 函数名称后加const
    • 函数体内不可以修改类成员属性
  • 常对象
    • 声明对象时前⾯加const
    • 不可以修改常对象的成员属性
    • 不能调用普通的成员方法，只能调⽤常函数

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;


class Account
{
private:
    
    double balance {0.0};

public:
    string name {"account"};

    void set_new_name(string new_name) const{ // 修改名字，加入const就不可以修改类成员属性，
        // name = new_name;
    }
    string get_name() const{ // 获取名字
        return name;
    }
    // 构造函数
    Account(string name = "none", double balance = 0.0);
    ~Account();
};

Account::Account(string name, double balance)
    : balance{balance} ,name{name}{
        cout << "构造函数" << endl;
}

Account::~Account()
{
    cout << "析构函数" << endl;
}


int main()
{
    // 常函数
    // Account alice_account {"Alice", 1000.0};
    // alice_account.set_new_name("Alice2"); // 修改名字
    // cout << alice_account.get_name() << endl; // Alice2

    // 常对象
    const Account bob_account {"Bob", 2000.0};
    // bob_account.name = "Bob2"; // 修改名字
    cout << bob_account.get_name() << endl; // Bob2
    
    return 0;
}

输出：

构造函数
Bob
析构函数
1.9 在类中使用static
  • 静态成员变量
    • 所有对象共享同⼀份数据（数据共享）
    • 在类中声明，类外初始化
  • 静态成员函数
    • 所有对象共享同⼀个函数
    • 只能访问静态成员变量

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Account
{
private:
    // 属性
    string name {"account"};
    double balance {0.0};
    static int num_accounts;
public:
    static int get_num_accounts();
    Account(string name, double balance);
    ~Account();
};

int Account::num_accounts {0};

Account::Account(string name, double balance)
    :name{name}, balance{balance}{
        num_accounts++;
    }

Account::~Account()
{
    num_accounts--;
}

int Account::get_num_accounts() // 不需要使用static关键字
{
    // 静态成员方法只能访问静态成员变量
    // name = "test";
    return num_accounts;
}
int main()
{
    cout << Account::get_num_accounts() << endl;
    Account alice_account {"Alice's account", 1000.0};
    cout << alice_account.get_num_accounts() << endl;
    Account bob_account {"Bob's account", 2000.0};
    cout << Account::get_num_accounts() << endl;
    
    {
        Account test_account {"test", 100.0};
        cout << Account::get_num_accounts() << endl;
    }
    cout << Account::get_num_accounts() << endl;
    return 0;
}

输出：

0
1
2
3
2
1.10 struct 和 class区别

唯一区别在于 class 成员权限默认是 private，而 struct 的成员权限默认是 public，

在这里插入图片描述

如果本博客对你有帮助，请点赞收藏吧😊😊😊

全息数据
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ OOP
Lightmare625
02-25 424
目录 1.概述 2.继承 2.0 基类 2.1 派生类 2.2 空基类优化（本节不理解 2.3 虚基类 2.4 继承方式 2.5 成员名称查找（不理解） 2.6 C++11新增 override final 3. 动态绑定 3.1 对象模型：虚表和虚指针 3.2 动态绑定的三个条件 3.3 static type和dynamic type区别 3.4 关于this...
C++-----深度探索C++对象模型-第四章-Function语意学（一）
一个人的学习和碎碎念
05-27 130
1、静态成员函数不可能做到下面两点：1）直接存取非静态成员变量（静态成员函数只属于类本身，随着类的加载而存在，不属于任何对象，是独立存在的，非静态成员当且仅当实例化对象之后才存在，静态成员函数产生在前，非静态成员函数产生在后，故不能访问，内部访问静态成员用::，而访问非静态成员要用this指针，静态成员函数没有this指针，故不能访问。）。2）不可能被声明为const（既然不能直接存取费静态成员变...
【C++】oop（面向对象）思想
qq_43411563的博客
05-10 1105
我们都知道C语言是面向过程的语言，C++是半面向对象的语言。 C语言中要实现一个功能的话就得将功能拆分成一个一个小的模板，模块中实现功能的时候是通过函数实现的，这就是所谓的模块化语言，它会形成函数调用链，然后最终形成最后的功能。 C++是面向对象的语言，那它到底是怎样实现的呢？第一个就是所谓的oop思想 一、oop思想 1、计算机语言的设计目的和意义 模拟现实。通过计算机语言实现现实中的问题 2、oop思想用图表示为： opp思想简单来说就是将属性和行为结合起来 二、代码实现计算机与现实世界的转换 例如：
【C++ | 面向对象思想】 C++ 的面向对象(OOP)思想详解：抽象、封装、继承、多态
最新发布
wkd_007的博客
05-30 1133
👉本文介绍了面向过程和面向对象的区别，然后介绍了几个面向对象的特性：抽象、封装、继承、多态。
[ C++ ] 带你一篇了解什么是OOP(面向对象编程)，什么是封装？ -- 类与对象（上）
CSDN博客
05-13 3504
学习过C语言的小伙伴知道：C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 面向过程编程也叫结构化编程。虽然结构化编程的理念提高了程序的清晰度，可靠性，并且方便维护。但它再编写大型的程序时，仍然面临这巨大的挑战，OOP(面向对象编程)提供了一种新的方法。与强调算法的过程性编程不同的是，OOP强调的是数据。--引自《C++ Primer Plus(第六版)》 1.面向对象编程 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
【C++学习】面向对象（oop）
weixin_44117376的博客
10-22 417
文章目录一、面向对象编程1.操作符重载2.copy问题3.析构函数4.value 与 reference5.reference 与 pointer二、示例1.类不含指针（Complex）2.类含指针（String） 一、面向对象编程 1.操作符重载 操作符重载的两种方法 成员函数方法：a.op(b); 全局函数+友元函数方法：op(a,b); 不能重载的操作符 . ?: :: sizeof 运算符重载不改变优先级 2.copy问题 深拷贝 和 浅拷贝 浅拷贝：类内变量创建副本，类内指针共享内存 深拷
C++编程学习(二) —— C++进阶编程
m0_66238629的博客
06-29 231
本阶段主要针对C＋＋面向对象编程技术做详细讲解，探讨C＋＋中的核心和精髓。
面向对象编程C++和Java比较教程
06-10
面向对象编程（Object-Oriented Programming，简称OOP）是一种重要的编程范式，它通过将数据和操作数据的方法封装在对象中，实现了代码的模块化和重用性。本教程聚焦于C++和Java这两种广泛使用的OOP语言的比较，旨在...
C++面向对象程序设课程设计大作业.zip
12-05
了解C++的基础语法，如变量、控制流、函数、指针等，是进行面向对象编程的前提。 2. **面向对象编程**：在C++中，对象是类的实例。类定义了对象的属性（数据成员）和行为（成员函数）。面向对象的四个核心概念包括...
面向对象编程C++和Java比较教程 中英文完整版 pdf
03-22
面向对象编程（Object-Oriented Programming，简称OOP）是一种重要的编程范式，它通过将数据和操作数据的方法封装在对象中，实现了程序设计的模块化和抽象化。本教程对比了两种广泛应用的面向对象语言——C++和Java...
简单易懂的C++的_oop入门学习资料
06-26
提升面对对象编程的思想。 很简单易懂的面对对象教程。 国外网站上找到的，英文版，不过都是口语化的很简单的英文，很容易看懂。
[大学经典课堂课件]C++课件-面向对象高级编程第一部分.pptx
08-27
C++是一种高级编程语言，它支持面向对象编程（Object Oriented Programming, OOP）和泛型编程（Generic Programming）。本文档将详细介绍C++面向对象高级编程的知识点，包括C++语言的历史、基本概念、类设计、继承、...
2023年面向对象程序设计C++山师习题答案.doc
10-26
* 面向对象程序设计（Object-Oriented Programming，OOP）是当前软件开发的主流编程范式。 * 面向对象程序设计的三个基本特征：封装、继承、多态。 二、类和对象 * 类（Class）是面向对象程序设计的基本概念，表示...
C++的OOP总结
小胡同的诗
09-05 1531
目录前言单类构造析构及初始化列表浅拷贝深拷贝赋值运算符重载几个重要的临时对象例子解析例1：默认拷贝构造产生临时对象例2：赋值运算符重载、拷贝构造设置不当产生临时对象、类内对象初始化列表例3：const修饰的引用传递产生临时对象例4：函数传递对象时的临时对象产生总结const修饰的方法及常对象初始化顺序多类嵌套多类继承权限及继承方式的权限问题构造析构继承的调用顺序父子类间的静态成员多继承虚函数重载、...
C++ 面向对象体系（OOP）背后的哲学思想
程序猿视角
08-01 533
用 Go 语言写了一些算法，被不伦不类的语法快把我折磨疯了。还是回归到 C++ 写算法吧。我觉得 C++ 的面向对象体系应该是所有语言中最科学的。这里简单列举若干特点，算是一个基本的总结。 C++ 引入OOP机制，其根本思路是，要让程序员利用 class 机制自行创建新数据类型。新的数据类型从形式上看，应该与 C++ 内置的 int、double 等数据类型完全一样。 例如，浮点数数组求和算法如下...
c++oop思想
Victor_psl的博客
07-23 305
oop：面向对象编程（object oriented programming），是一种计算机编程架构。 对象是由数据和容许的操作组成的封装体，和客观实体有直接对应关系，一个对象类定义了具有相似性质的一组对象。而继承性是具有层次关系的类的属性和操作进行共享的一种方式。所谓面向对象就是基于对象概念，以对象为中心，以类和继承为构造机制，来认识理解、刻画客观世界和设计、构造相应的软件系统。 属性和方法的集合就形成了类，类是面向对象编程的核心和基础，类在实例化后就是对象。 对象的产生： 一：是以原型对象为基础

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值