1static强化练习-仓库进货和出货
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
class Goods
{
public:
// 无参数的构造函数
Goods()
{
next = NULL;
weight = 0;
cout << "创建了一个货物重量是" << 0 << "的物品" << endl;
}
// 有参数的构造函数
Goods(int w)
{
weight = w;
next = NULL;
// 每创建一个货物 总重量应该加
cout << "创建了一个货物重量是" << w << "的物品" << endl;
taotal_weight += w;
}
// 提供一个静态的成员函数来访问静态成员
static int getTotal()
{
return taotal_weight;
}
~Goods()
{
cout << "删除了一箱重量是" << weight << "货物" << endl;
taotal_weight -= weight;
}
// 给货物类变成一个链表的节点
Goods * next;
private:
int weight; // 货物的重量
static int taotal_weight; // 所有货物的总重量
};
// 一开始所有货物总重量是0
int Goods::taotal_weight = 0;
// 进货的方法
void buy(Goods* &head,int w)
{
// 创建一个新的货物
Goods *new_goods = new Goods(w); // 通过new在堆上开辟空间，调用了Goods类的有参构造函数
if (head == NULL) {
// 如果head是空
head = new_goods; //无头链表
}
else
{
// 如果head不为空,从head表头添加
new_goods->next = head;
head = new_goods;
}
}
// 出货的方法
void sale(Goods * &head)
{
if (head == NULL) {
cout << "仓库已经没有货物了" << endl;
return;
}
Goods *temp = head;
head = head->next;
delete temp;
cout << "saled " << endl;
}
int main(void)
{
int choice = 0;
Goods *head = NULL; // 所有货物的表头
do {
cout << "1 进货" << endl;
cout << "2 出货" << endl;
cout << "0 退出" << endl;
cin >> choice;
switch (choice)
{
case 1:
// 进货
cout << "请输入要创建的货物的重量" << endl;
int w;
cin >> w;
buy(head, w);
break;
case 2:
// 出货
sale(head);
break;
case 0:
// 退出
return 0;
break;
default:
break;
}
cout << "此时仓库中有" << Goods::getTotal() <<"重量的货物" << endl;
} while (1);
return 0;
}
1 昨日回顾
3 this指针
4全局函数和成员函数
多次调用的实现
5 强化练习2-封装一个自定义的数组类
6 友元函数
7 友元类和友元的规则
友元是单向的。
8中午回顾
9操作符重载的概念
10 操作符重载的规则
.*符号:
↑ 这两个参数都是普通类型 这种运算法则编译器已经写好了(必须有一个自定义类型
11 双目运算符重载
全局函数:
注意:这里最好写引用Complex &,不是直接写Complex
a+=b+=c 这个双目运算符的计算 (a+=(b+=c))
如果之前写法没有引用的话
虽然是正确的
但是返回的是匿名临时对象 然后把匿名临时对象的值给真实的C1
最好是写引用的写法 直接修改C1
成员函数:只能写一个参数
12单目运算符重载前++和- -
全局函数:
成员函数:
13 单目运算符后++
占位操作符
// 亚元
a++ // 单目运算符
全局函数:
成员函数:
14操作符重载输入输出操作符
比如我想把虚数cout出来:
原理:
<< 这个双目运算符传入cout 和 c12
(报错显示:没有找到重载)
展开找一下cout和cin的类型
重写:
加上连等功能:
(普通双目操作符的成员函数操作符重载)
cin操作符重载:
15等号操作符
定义一下深拷贝浅拷贝:
浅拷贝,直接复制一份和原来一样的(结果导致里面可能有相同的引用
深拷贝,按逻辑的复制一份新的
当执行s3=s1的时候,
有个两个问题:
- li4泄露了
- zhangsan重复释放
等号操作符默认也是浅拷贝,但是相比拷贝构造有一个风险,
即:当调用拷贝构造函数的时候,一定是初始化,
但当调用等号操作符的时候,可能里面已经有值了，所以应该判断一下，如果有值就释放掉
代码:
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
class Student
{
public:
Student(int id,const char *name)
{
this->id = id;
int len = strlen(name);
this->name = (char*)malloc(len + 1); // 将name在堆上开辟一个空间
strcpy(this->name, name);
}
// 防止浅拷贝 提供一个显示的拷贝构造函数
Student (const Student & another_s)
{
this->id = another_s.id;
int len = strlen(another_s.name);
this->name = (char *)malloc(len + 1);
strcpy(this->name, another_s.name);
}
// 重写等号操作符
// 返回值用引用来实现连等
Student & operator=(const Student & another_s)
{
if (this->name != NULL)
{
// 原来有数据 需要释放
delete[] this->name;
this->name = NULL;
this->id = 0;
}
// 到这为止,之前的数据释放完毕
this->id = another_s.id;
int len = strlen(another_s.name);
this->name = (char *)malloc(len + 1);
strcpy(this->name, another_s.name);
return *this;
}
~Student()
{
if (this->name != NULL)
{
delete[] this->name;
this->name = NULL;
this->id = 0;
}
}
void printS()
{
cout << "id: " << this->id << ", name = " << this->name << endl;
}
private:
int id;
char *name; // 准备在堆上开辟空间
} ;
int main(void)
{
Student s1(1, "张三");
Student s2(s1); // 当你调用拷贝构造的时候,一定是初始化
Student s3(2, "李四"); // 已经有内存分配了
s3 = s1; // 不是调用拷贝构造 //编译器也给我们提供了一个默认的=操作符
s1.printS();
return 0;
}