C++实现的银行账户管理系统

weixin_47827716

已于 2023-02-25 19:22:33 修改

阅读量3.2k

点赞数

文章标签： c++

于 2023-02-25 19:00:27 首次发布

本文链接：https://blog.csdn.net/weixin_47827716/article/details/129216976

版权

基本实现思路：以account类（账户）为主线，其与date类（日期）是组合关系以date类的对象作为数据成员。user类（用户）和list类（管理员）本质上是两个链表，它们都以account类作为链表结点。

主要功能：

friend关键字/operator重载：

friend两种基本使用方法：

（1）A类中申明func()函数为friend，则func()可以使用A类的所有成员变量

（2）A类中申明B类为friend，则使用A类的所有成员变量

重载两种方式：

（1）如果一个重载运算符是类的成员函数，那么只有当与它一起使用的左操作数是该类的对象时，该运算符才会被调用；

（2）而如果该运算符的左操作数确定为其他的类型，则运算符必须被重载为全局函数；

#pragma once
#include<iostream>
using namespace std;
class date {
public:
	date(int y = 0, int m = 0, int d = 0);
	void setdate(int y, int m, int d);
	int gyear();
	int gmonth();
	int gday();
	date& operator=(const date& r);
	void display();
	bool operator>(const date& right);
	friend ostream& operator<<(ostream& out, date& r);// friend + 重载
    friend bool operator==(const date& a, const data& b);
protected:
	int year;
	int month;
	int day;
};
ostream& operator << (ostream &os , data a) {
    os << "your data is " << a.year << a.month << a.day << endl;
    return os;
}

bool date::operator>(const date& right) {//重载成员函数
	int t = 1;
	if (year > right.year)t = 0;
	else if (month > right.year)t = 0;
	else if (day > right.day)t = 0;
	return t;
}
bool operator==(const date& a, const data& b) {//重载全局函数
	if (a.year == b.year && a.month == b.month && a.day == b.day)return true;
}
 
int main() {
    data a;
    data b;
    cout << a;
    if(a>b) cout<<1;//相当于对象 a 调用函数“operator>”，把对象 b 作为一个参数传递给该函数
    if(a==b) cout<<0;//对象a,b都为bool operator==(...)的参数
    system("pause");
}

const：

常量：用const修饰变量时，一定要给变量初始化，否则之后就不能再进行赋值了。

const int n=5;
int const n=5;
//变量n的值不能被改变

常量指针：指针指向的内容是常量，指针地址可变。

不能通过这个指针改变变量的值，可以通过其他的引用来改变变量的值。

int a = 5;
const int * b = &a;
//int const * b = &a;
a = 6;//b值可变

指针常量：指针本身是常量，指针地址不可变，指针内容可变。

int * const n;

修饰函数参数：

1）防止指针指向的内容被修改

void func( const int * a );

2）防止指针指向的地址被修改

void func(int * const a );

修饰函数的返回值：如果函数返回值加 const 修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。

const int * getf(...);
int * a = getf(...);//×
const int * b = getf(...);//√

const可用来修饰成员函数，使得该函数只能访问数据成员而不能修改数据成员
const可用来修饰对象，使得该对象只能调用const修饰的成员函数

static：

静态局部变量：

无static：每调用一次fun()，val重新初始化

有static：val只初始化一次之后每次调用fun()都对val进行累加。变量的存储区域由栈变为静态常量区，生命周期由局部变为全局，直到程序运行结束以后才释放。

#include <stdio.h>

void fun()
{
	static int val = 0;   //static 修饰局部变量
	val++;
}
int main()
{
	for (int i = 0; i < 7; i++){
		fun();
	}
	return 0;
}

静态全局变量（≈static修饰函数）：变量的作用域由整个程序变为当前文件。全局变量只能在定义变量的当前文件使用，不能在其余文件使用，即使extern外部声明也不行。

静态成员变量：

class A
{
public :
	A(){   //构造函数  静态成员变量无法在构造函数初始化列表进行初始化
		_count++;
	}
	A(const A& y){
		_count++;
	}
	static int GetCount(){    //静态成员函数
		return _count;
	}
public:  //静态成员变量也受访问限定符（public、protected、private）的限制。     
	int a;
	//静态成员变量在类中声明，在类外初始化
	static int _count;  
	static const int sa = 99;//const修饰的静态成员变量可以在类内初始化
	const static int sb;
	static const int sc;
};

int A::_count = 0;   //静态成员变量在使用前必须先初始化，在类外初始化，不用加static
const int A::sb = 88;
const int A::sc = 77;

void TestA() {
	cout << A::GetCount() << endl;  // 类静态成员通过 "类名::静态成员" 来访问
	A a1, a2; 
	A a3(a1);
    cout << A::GetCount() << endl;   
                          //静态成员为所有类对象所共享，并没有包含在具体的对象中。
	cout << a3.GetCount() << endl;   //或 类静态成员通过 "类对象名.静态成员" 来访问
}

静态成员函数：

1）静态成员函数没有隐藏的this指针，也不能定义成this成员函数。因为静态成员为所有类对象所共享，并没有包含在具体的对象中。

2）非静态成员可以访问静态成员，静态成员不可以访问非静态成员只能访问静态成员。

文件：系统实现采用文件的输入输出流对文本数据进行读取与写入。

单链表：对数据的存储组织使用了单向链表实现增、删、改、查、排序功能