当前位置： 首页 > news >正文

C++ primer plus 类和对象上

news 来源：原创 2025/5/18 14:32:28

目录

前言

一  接口的设计

二  方法的设计和使用

三  构造函数

 四  析构函数

五  析构函数和构造函数小结

总结

前言

前面已经描述了很多有关于类和对象的知识了，所以我们直接开始上手操作

一  接口的设计

首先我们要知道什么是接口
接口是一个共享框架，供两个系统(如在计算机和打印机之间或者用户或计算机程序之间)交互时使 用;例如，用户可能是您，而程序可能是字处理器。 使用字处理器时，您不能直接将脑子中想到的词传输 到计算机内存中，而必须同程序提供的接口交互
您打键盘时，计算机将字符显示到屏幕上;您移动鼠标时，计算机移动屏幕上的光标;您无意间单击鼠标时，计算机对您输入的段落进行奇怪的处理。 程序接 口将您的意图转换为存储在计算机中的具体信息。 对于类，我们说公共接口。 在这里，公众 (public) 是使用类的程序，交互系统由类对象组成，而接口由编写类的人提供的方法组成。接口让程序员能够编写与类对象交互的代码，从而让程序能够使用类对象。 例如，要计算stnng对象中包含多少个字符，您无需打开对象，而只需使用 stríng 类提供的 size()方法。 类 设计禁止公共用户直接访问类，但公众可以使用方法size()。 方法size()是用户和 string类对象之间的公共接口的组成部分。 通常，方法getline()是 istream 类的公共接口的组成部分，使用 cin 的程序不是直接与 cin 对象内部交互来读取一行输入，而是使用 getline()。 如果希望更人性化，不要将使用类的程序视为公共用户，而将编写程序的人视为公共用户。 然而，要使用某个类，必须了解其公共接口，要编写类，必须创建其公共接口

通常， C++程序员将接口(类定义)放在头文件中，并将实现(类方法的代码〉放在源代码文件中
我们要养成一个习惯，为了区分，我们类的首字母是需要大写的，接口往往就是我们设计在public里的函数，然后通过这个可以间接访问到里面private里面私密变量

下面我们就来设计一个接口

#ifndef __COOL__H__
#define __COOL__H__

#include<string>

class Stock {
private:
	std::string company;
	long shares;
	long share_vale;
	long total_vale;
	void set_tot() {
		total_vale = shares * share_vale;
	}

public:
	void acquire(const std::string& co, long n, double pr);
	void buy(long num, double price);
	void sell(long num, double price);
	void updata(double price);
	void show();
};

#endif

以上是我在cool.h里设计的一个类
那么这里的public的意思就是公用的，也就是说可以在外部进行访问
关键字publlc标识组成类的公共接口的类成员(抽象)
private就是私密的，也就是只有类里面才可以进行访问，外部是访问不到的

这个里面的数据是隐藏的
数据隐藏不仅可以防止直接访问数据，还让开发者(类的用户)无需了解数据是如何被表示的。例如， show( )成员将显示某支股票的总价格(还有其他内容)，这个值可以存储在对象中(上述代码正是这样做 的)，也可以在需要时通过计算得到。从使用类的角度看，使用哪种方法没有什么区别。 所需要知道的只是 各种成员函数的功能:也就是说，需要知道成员函数接受什么样的参数以及返回什么类型的值。原则是将实现细节从接口设计中分离出来。如果以后找到了更好的、实现数据表示或成员函数细节的方法，可以对 这些细节进行修改，而无需修改程序接口，这使程序维护起来更容易

其实C++如果你没有设置他是public还是private的话，那么就是默认是private，只是我们在平时编写代码的时候要养成好的习惯，这样也可以增加可读性

在C++里面结构体也是可以使用方法的也就是放入函数，但是与类不一样的地方就是，结构体无论是什么数据还是方法都是公开的，但是class可以设置公开与隐藏
 

当我们在private里面设置了一个函数，这个函数就是一个内联函数，但是下面public不是内联函数，那个只是一个接口，而不是一个内联函数，如果你想把他编程内联函数的话，那么就直接在编写函数

二  方法的设计和使用

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

//表示公司首次购买股票
void Stock::acquire(const std::string& co, long n, double pr) {
	company = co;
	if (n < 0) {
		std::cout << "Number of shares can't be negative;"
			<< company << "shares set to 0.\n";
		shares = 0;
	}
	else {
		shares = n;
		share_vale = pr;
		set_tol();
	}
}

//增加股票
void Stock::buy(long num, double price) {
	if (num > 0) {
		std::cout << "Number of shares can't be negative;"
			<< "Transaction is aborted.\n";
	}
	else {
		shares += num;
		share_vale = price;
		set_tol();
	}
}

//减少股票
void Stock::sell(long num, double price) {
	using std::cout;
	if (num < 0) {
		std::cout << "Number of shares can't be negative;"
			<< "Transaction is aborted.\n";
	}
	else if (num > shares) {
		cout << "You can't sell more than you have!"
			<< "Transaction is aborted.\n";
	}
	else {
		shares -= num;
		share_vale = price;
		set_tol();
	}
}

//更新
void Stock::update(double price) {
	share_vale = price;
	set_tol();
}

//展示
void Stock::show() {
	std::cout << "compay: " << company
		<< "shares:" << shares << '\n'
		<< "share price: $" << share_vale
		<< "total worth: $" << total_vale << '\n';
}

 这个就是我们根据类来进行编写这个成员函数，这个成员函数是可以简介访问private里的值的
 

接下来就是书写就是这个使用这个方法

#include<iostream>
#include"cool.h"
using namespace std;

int main() {
	Stock cat;
	cat.acquire("zhang", 1, 19.25);
	cat.show();
	cat.buy(3, 19.23);
	cat.show();
	cat.sell(1, 20);
	cat.show();
	return 0;
}

一般来说数据是放到private里，public一般放的是方法 

三  构造函数

1  构造函数
由于我们很多变量都是需要初始化的，比如我们定义一个变量要对他进行初始化，但是再类里面，我们要对private里面的变量进行初始化，我们通过直接的访问进行初始化肯定是不行的，但是我们可以通过函数来进行修改，我们知道public是可以间接访问到private里面的变量的

就比如我们上面有一个函数

void Stock::acquire(const std::string& co, long n, double pr) {
	company = co;
	if (n < 0) {
		std::cout << "Number of shares can't be negative;"
			<< company << "shares set to 0.\n";
		shares = 0;
	}
	else {
		shares = n;
		share_vale = pr;
		set_tol();
	}
}

但是这个不是构造函数，这个只是其中的一个成员函数
那么我们要怎么改写成构造函数
1  构造函数无返回值
2  函数名字与类的名字相同
3  形参的名字不可以跟private赋值的成员变量的名字一样

//表示公司首次购买股票
Stock::Stock(const std::string& co, long n, double pr) {
	company = co;
	if (n < 0) {
		std::cout << "Number of shares can't be negative;"
			<< company << "shares set to 0.\n";
		shares = 0;
	}
	else {
		shares = n;
		share_vale = pr;
		set_tol();
	}
}


声明
Stock(const std::string& co, long n, double pr);

对于名称的设置



这样我们就得到了一个构造函数，但是我们要怎么使用这个构造函数呢？
使用构造函数的方式有两个
1  显式使用构造函数
2  隐式使用构造函数

1  显式  Stock food = Stock("World Cabbage" , 250 , 1.25 );
2  隐式  Stock garmnent ("Furry Mason", 50 , 2.5) ;  
等同于Stock garment = Stock(" Furry Mason" , 50 , 2.5));
3  每次创建类对象(甚至使用new动态分配内存)时， C++都使用类构造函数。下面是将构造函数与new 一起使用的方法: Stock *pstock = new Stock("Electroshock Games ", 18 , 19 .0);

2  默认构造函数
当我们类里面没有写构造函数的话，那么编译器是会给类一个默认构造函数，但是编译器给的默认构造函数里面是空的，什么都没有，就像下面这个例子一样
Stock: :Stock() { }

我们该怎么创建构造函数呢？
下面有两个方法
方法一：基于上述构造函数在函数的声明里面加入默认值

Stock(const std::string& co = "no name", long n = 0, double pr = 0);

 这样我们就可以设置默认值了

方法二：写一个没有任何参数的默认构造函数
这个是通过函数的重载写的，由于只能有一个默认构造函数，因此不要同时采用这两种方式

我们需要区分默认构造和构造，还要学会使用构造 

 构造函数的陷阱
首先我们创建一个构造函数的时候，则编译器不会再给我提供默认构造函数，所以当我们创建一个变量，没有调用自定义的构造函数将变量进行初始化的话，那么就会报错，因为没有初始值

 四  析构函数

当我们在使用完类的时候，我们的对象是需要"释放"的
就比如我们在写了一个角色的时候，角色的重生是利用构造函数，角色的死亡是利用析构函数
当我们在没有写析构函数的时候，计算机是会给我们默认析构函数，这个默认的析构函数就类似于我们默认的构造函数，这个编译器是空的参数列表并且代码块是空的，如果我们用默认构造函数去用new创建一个对象，然后我们就使用析构函数使用delete来释放这个new释放的对象

析构函数是无返回值和没有类型的声明的

什么时候调用析构函数呢？
这个是由我们编译器决定的
如果是静态的，析构函数是在程序结束的时候被调用
如果是自动的，析构函数是在这个代码块执行完被调用
如果是new创建的，析构函数是在delete释放之后被调用

我们来改进一下我们之前的代码，加入我们的析构函数
首先我们更改一下我们的头文件

#ifndef __COOL__H__
#define __COOL__H__

#include<string>

class Stock {
private:
	std::string company;
	long shares;
	long share_vale;
	long total_vale;
	void set_tol() {
		total_vale = shares * share_vale;
	}

public:
	Stock(const std::string& co = "no name", long n = 0, double pr = 0);
	~Stock();
	void buy(long num, double price);
	void sell(long num, double price);
	void update(double price);
	void show();
};

#endif

工具函数 

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

//表示公司首次购买股票
Stock::Stock(const std::string& co, long n, double pr) {
	company = co;
	if (n < 0) {
		std::cout << "Number of shares can't be negative;"
			<< company << "shares set to 0.\n";
		shares = 0;
	}
	else {
		shares = n;
		share_vale = pr;
		set_tol();
	}
}

Stock::~Stock() {
	std::cout << "bey bey" << std::endl;
}

//增加股票
void Stock::buy(long num, double price) {
	if (num < 0) {
		std::cout << "Number of shares can't be negative;"
			<< "Transaction is aborted.\n";
	}
	else {
		shares += num;
		share_vale = price;
		set_tol();
	}
}

//减少股票
void Stock::sell(long num, double price) {
	using std::cout;
	if (num < 0) {
		std::cout << "Number of shares can't be negative;"
			<< "Transaction is aborted.\n";
	}
	else if (num > shares) {
		cout << "You can't sell more than you have!"
			<< "Transaction is aborted.\n";
	}
	else {
		shares -= num;
		share_vale = price;
		set_tol();
	}
}

//更新
void Stock::update(double price) {
	share_vale = price;
	set_tol();
}

//展示
void Stock::show() {
	std::cout << "compay: " << company << " "
		<< "shares:" << shares << '\n'
		<< " share price: $" << share_vale
		<< " total worth: $" << total_vale << '\n';
}

主函数

#include<iostream>
#include"cool.h"
using namespace std;

int main() {
	Stock cat("cat", 10, 100.19);
	cat.show();
	Stock dog("dog", 5, 105.19);
	dog.show();
}

然后我们就直接写好了，我们运行一下看看结果是什么

我们可看到这个结果这个dog是在上面的，但是这个cat是在下面的，这就说明了这个对象的存储是按照栈的顺序进行存储的

在C++11 中，可将列表初始化语法用于类吗?
可以，只要提供与某个构造函数的参数列表匹配的内容， 并用大括号将它们括起:

Stock hot_tip = {"erivatives Plus Plus", 100, 45 .0}; 
Stock j ock {" Sport Age Storage, Inc" }; 
Stock temp {};

 这种方法不推荐，但是要知道有这个方式

const成员函数
下面我们来看一个样例

const Stock land = Stock("Kludgehorn Properties") ; 
land.show () ;

这个是不被允许的，为什么？因为我们这个成员是const的常量，然后我们来看看我们show函数里面的代码

void Stock::show() {
	std::cout << "compay: " << company << " "
		<< "shares:" << shares << '\n'
		<< " share price: $" << share_vale
		<< " total worth: $" << total_vale << '\n';
}

 其实这个代码里面并没有常量指针进行接受，或者常量引用来进行接受，那么就会导致编译器认为，你这个是不安全的，不可以保护company这个常量，所以就会报错，因为编译器认为不安全

这个时候我们除了用const指针和const引用的方法，还有一个方法就是在这个函数的末尾加上const来进行表示

void show () const; 
/ / promises not to change invoking object 
 void stock::show() const 
/ / promises not to change invoking object

我们在函数的声明和函数的末尾都需要加上const来承诺这个是不可以改变的
以这种方式声明和定义的类函数被称为 const成员函数。就像应尽可能将const引用和指针用作函数形 参一样，只要类方法不修改调用对象，就应将其声明为 const，这种方式被称为常量成员函数

五  析构函数和构造函数小结

下面我们来小结一下结构函数和析构函数

结构函数
结构函数的名字和类的名字是一样的，前面也要记得加上类名字和作用域
首先结构函数分为结构函数和默认结构函数

结构函数就是我们自定义的，需要传参数进行初始化赋值的，如果我们创建了之后，编译器就不会出现再给我们提供默认构造函数了，如果你不调用进行初始化，那么就会报错，报错为找不到默认函数，所以我们创建了就要进行初始化
1  显式  Stock food = Stock("World Cabbage" , 250 , 1.25 );
2  隐式  Stock garmnent ("Furry Mason", 50 , 2.5) ;  

默认构造函数
默认构造函数就是我们不进行传参数，然后直接进行赋值
默认构造函数是只有隐式
1  隐式  就是定义变量就好了，为什么没有显示，上面有

析构函数
析构函数就是我们需要注意它的存储方式
还有就是析构函数就是我们需要注意传参是const的时候，再函数声明和函数加上const的，或者需要利用常量引用和常量指针

如果我们只有一个参数的时候，我们可以直接这么初始化

Bozo FUFU = 32

直接用等于号

总结

我们学习了怎么设计类，头文件应该放什么，方法应该放到哪里，还有就是析构函数和构造函数需要注意的

相关文章：

  • Spring Security 的认证核心组件
  • 【mysql】centOS7安装mysql详细操作步骤！
  • Windows10安装Rust 和ZED（失败）
  • P6772 [NOI2020] 美食家
  • WebSocket的参数粗略解释
  • AVL树的平衡算法的简化问题
  • 数据类型及sizeof，进制转换
  • go中实现子模块调用main包中函数的方法
  • /etc/sysconfig/jenkins 没有这个文件
  • 计算机网络-TCP/IP协议族
  • 无再暴露源站！群联AI云防护IP隐匿方案+防绕过实战
  • netsh实现TCP端口转发
  • 40.动态规划13
  • Ansible命令行模式常用模块使用案例（三）
  • Python与Solidity联手：从跨语言智能合约开发到区块链生态跃迁
  • 实习笔试-01字符转换小写字母
  • 【AWS入门】2025 AWS亚马逊云科技账户注册指南
  • 《解锁华为黑科技：MindSpore+鸿蒙深度集成奥秘》
  • A Survey on Mixture of Experts 混合专家模型综述(第二部分：混合专家系统设计)
  • 机器学习基础
  • 上海这场有温度的“人才集市”，为更多人才搭建“暖心桥”
  • 浙江理工大学传播系原系主任刘曦逝世，年仅44岁
  • 外交部驻港公署正告美政客：威胁恫吓撼动不了中方维护国家安全的决心
  • 澎湃与七猫联合启动百万奖金征文，赋能非虚构与现实题材创作
  • 阿里上季度营收增7%：淘天营收创新高，AI产品营收连续七个季度三位数增长
  • 视频丨中国海警成功救助8名外籍遇险渔民，韩方向中方致谢