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

c++学习

ds 2025/5/4 12:17:10

1.某学校教职工的工资计算方法为:
2.1.所有教职工都有基本工资
3.2.教师月工资为固定工资+课时补贴，课时补贴根据职称号不同有所不同，例如
4.每课时教授补贴50元，副教授补贴30元，讲师补贴20元。
5.3.管理人员月薪为基本工资+职务工资。
6.4.实验室人员月薪为基本工资+工作日补贴，工日日补贴等于日补贴*月工作日数
7.定义教职工抽象类，派生教师类，管理人员类和实验室类，编写程序测试这个类体系

#include <iostream>
using namespace std;class Employee {   // 定义教职工抽象类
protected:string name;   // 姓名int basic_salary;   // 基本工资
public:Employee(string n, int s) : name(n), basic_salary(s) { }virtual int get_salary() = 0;   // 纯虚函数，子类必须实现virtual void printInfo() = 0;   // 纯虚函数，子类必须实现
};class Teacher : public Employee {   // 定义教师类
private:int teach_hours;   // 教学课时string title;   // 职称
public:Teacher(string n, int s, int h, string t) : Employee(n, s), teach_hours(h), title(t) { }int get_salary() {double teachingAllowance = 0;if (title == "教授") {teachingAllowance = teach_hours * 50;}else if (title == "副教授") {teachingAllowance = teach_hours * 30;}else if (title == "讲师") {teachingAllowance = teach_hours * 20;}return basic_salary + teachingAllowance;}void printInfo() {cout << "教师姓名：" << name << endl;cout << "基本工资：" << basic_salary << endl;cout << "职称：" << title << endl;cout << "课时数：" << teach_hours << endl;cout << "月工资：" << get_salary() << endl;}
};
class Manager : public Employee {   // 定义管理人员类
private:int duty_salary;    // 职务工资
public:Manager(string n, int s, int d) : Employee(n, s), duty_salary(d) { }int get_salary() {return basic_salary + duty_salary;}void printInfo() {cout << "管理人员姓名：" << name << endl;cout << "基本工资：" << basic_salary << endl;cout << "职务工资：" << duty_salary << endl;cout << "月工资：" << get_salary() << endl;}
};class LabStaff : public Employee {   // 定义实验室人员类
private:int workdays_per_month;   // 每月工作日数int daily_allowance;   // 日补贴
public:LabStaff(string n, int s, int d, int a) : Employee(n, s), workdays_per_month(d), daily_allowance(a) { }int get_salary() {return basic_salary + workdays_per_month * daily_allowance;}void printInfo() {cout << "实验室人员姓名：" << name << endl;cout << "基本工资：" << basic_salary << endl;cout << "日补贴：" << daily_allowance << endl;cout << "月工作日数：" << workdays_per_month << endl;cout << "月工资：" << get_salary() << endl;}
};/*这个程序定义了一个Employee类作为教职工的抽象类，派生出Teacher类、Manager类和LabStaff类分别表示教师、管理人员和实验室人员。这些子类都实现了get_salary()纯虚函数，计算每个员工的月薪。在main()函数中，我们创建了一个指向Employee对象的指针数组，数组中存放了4个不同类型的员工。然后我们遍历数组，*/
int main() {Employee* employees[4]; // 定义一个指向Employee对象的指针数组employees[0] = new Teacher("张三", 5000, 80, "教授");employees[1] = new Manager("李四", 6000, 2000);employees[2] = new LabStaff("王五", 4000, 22, 30);employees[3] = new Teacher("赵六", 4500, 60, "副教授");for (int i = 0; i < 4; i++) {employees[i]->printInfo();}return 0;
}8.1.编写程序定义类MyArray
9.2.重载运算符“+”、“-”、“*”和“=”，实现数组直接的加、减、乘、赋值运算
10.3.重载运算符“>>”、“<<”，实现向量输入输出功能
11.4.测试运算的组合算法
#include <iostream>
using namespace std;class MyArray {
private:int size;int* data;
public:MyArray(int s = 0) :size(s) {   // 构造函数data = new int[size];}~MyArray() {   // 析构函数delete[] data;}MyArray(const MyArray& other) {   // 拷贝构造函数size = other.size;data = new int[size];for (int i = 0; i < size; i++) {data[i] = other.data[i];}}MyArray operator+(const MyArray& other) const {   // 重载运算符+if (size != other.size) {cout << "两个数组大小不一致，不能相加" << endl;exit(-1);}MyArray result(size);for (int i = 0; i < size; i++) {result.data[i] = data[i] + other.data[i];}return result;}MyArray operator-(const MyArray& other) const {   // 重载运算符-if (size != other.size) {cout << "两个数组大小不一致，不能相减" << endl;exit(-1);}MyArray result(size);for (int i = 0; i < size; i++) {result.data[i] = data[i] - other.data[i];}return result;}MyArray operator*(const MyArray& other) const {   // 重载运算符*if (size != other.size) {cout << "两个数组大小不一致，不能相乘" << endl;exit(-1);}MyArray result(size);for (int i = 0; i < size; i++) {result.data[i] = data[i] * other.data[i];}return result;}MyArray& operator=(const MyArray& other) {   // 重载运算符=if (this == &other) {return *this;}delete[] data;size = other.size;data = new int[size];for (int i = 0; i < size; i++) {data[i] = other.data[i];}return *this;}friend istream& operator>>(istream& is, MyArray& arr) {   // 重载运算符>>for (int i = 0; i < arr.size; i++) {is >> arr.data[i];}return is;}friend ostream& operator<<(ostream& os, const MyArray& arr) {   // 重载运算符<<for (int i = 0; i < arr.size; i++) {os << arr.data[i] << " ";}os << endl;return os;}
};int main() {MyArray arr1(5), arr2(5), arr3(5);   // 测试向量输入输出cout << "请输入第一个向量：";cin >> arr1;cout << "请输入第二个向量：";cin >> arr2;arr3 = arr1 + arr2;cout << "arr1 + arr2 = " << arr3;arr3 = arr1 - arr2;cout << "arr1 - arr2 = " << arr3;arr3 = arr1 * arr2;cout << "arr1 * arr2 = " << arr3;return 0;
}

#include //头文件包含，标准输入输出流 C++有行注释、块注释，没有文件注释
using namespace std; //使用命名空间

//有且只有main函数，它是系统的唯一入口,形参可省略
int main(int argc,char *argv[])
{
cout<<”hello world”<<endl;
return 0; //主函数必须有return ;return有两个功能，一是返回一个数据类型，二是结束当前函数
}
extern int date; int date = 0; //先声明，后定义，extern只能在函数外部使用，用于声明类、函数和全局变量，一般跨文件才使用声明，同文件可以直接先定义再调用

int date = 0;int num = 0; cin>>date>>num; //键盘输入给date、num赋值，以空格或回车隔开(cin会忽略空格回车)

字符常量：’a’、’123’等字符变量：char ch = ‘\0’;
字符串常量：”a”、”123”等字符串变量：string str = “name”;

const关键字：const修饰的变量为只读变量，在定义变量时要初始化，被初始化后不能被赋值。

typedef关键字：给已类型或其他取个别名，如typedef int INT32，INT32就代表int关键字，typedef后面紧跟被替代的

随机函数：include <time.h> srand(time(NULL)); int a = rand();

int arr[] = {10,20,30,40,50}; int arr [5] = {10,20}; int arr = {0,[2]=10};//数组初始化、部分初始化(自动补0)

函数声明和实现：int getName(int id); //声明，就是函数除去函数体部分
string getName( int id){return name;} //实现

int &b = a; int arr[5] = {0};int (&myarr)[5] = arr; int p = num; int &myp =p;

void fun(void){} void (&myfun)(void) = fun; //别名必须初始化，对b操作与对a操作完全等价

引用的使用：定义函数void fun(int &x,int&y){int tmp = x;x = y;y = tmp;} 调用int a = 10,b = 20; fun(a,b); //相当于指针功能，但比指针方便简洁

常应用：void fun(const int &t){} //作为函数的参数，防止内部修改外部的值

内联函数：在定义的时候用inline修饰的函数，但这个函数在声明的时候不能使用inline 如inline int fun(const int &x){}

函数重载：与java规则一致

默认参数：void testfun(int x= 0,int b = 10){} //当函数调用时没有指定值，系统默认给没赋值的形参赋值，默认参数从左到右，第一个默认参数后面都必须是默认参数，如果函数存在声明，在声明处设置默认参数

占位参数：void testfun(int x= 0,int b = 10,int = 10){} //占位参数无法使用，只是告诉函数必须要给占位参数传个值，与默认参数一样，如果函数存在声明，在声明处设置占位参数

类：class A{ //类的成员变量一般设计为私有private，成员函数一般设计为公有public
private: //默认private，不能在对象外部访问，如cout<<student.a<<endl;只能被类内公共函数调用
int a；
public: //可以在对象外部访问，如cout<<student.b<<endl;
int b;
void fun(void){ … }
}; A student; //创建一个A类对象
成员函数：一般在类中声明，在类外实现
class Date{
private:
int a;
public:
void seta(int _a);
int geta();
Date() //构造函数实现和重载规则与java一致
析构函数： ~Date() //默认析构函数，清理对象使用空间的功能，完成释放内存的前置工作，析构函数没有重载，
但可以自己实现析构函数，在析构函数中添加操作，析构和创建函数遵循同级别时(同一个语句块内)先创建的后析构的规则。一般在类中存在指针成员时，要自己定义析构函数delete释放指针空间同时也要定义拷贝构造函数，实现深拷贝
} //类中声明成员函数

void Date::seta(int _a){a = _a;}   int Date:: geta(){return a;}	//类外实现函数

拷贝构造：用就对象给新对象赋值时系统自动调用拷贝构造函数。如果用户定义了拷贝构造、有参构造都会屏蔽无参构造，如果用户定义了有参构造和无参构造，不会屏蔽拷贝构造函数。拷贝构造函数是特殊的构造函数

Date(const Date &ob){a = ob.a(成员变量一一赋值)}		//浅拷贝Date a = b；把成员b赋给成员a

动态创建和释放对象：Date* p = new Date; Date* q = new Date(1,2); delete p;delete q; //new创建指针指向对象

this关键字：保存调用该成员函数的对象的地址 this->a = b

友元函数：一种特权函数，C++允许这个特权函数访问本类私有成员用friend修饰，只能在声明处出现
全局函数作为友元函数：friend void getvalue(Date &data );
某类的成员函数作为友元：friend Get:: void getvalue(Date &data );
某类作为友元类：friend classGet; //任何友元都不能被继承

运算符重载：对已有运算符重新进行定义，赋予其另一种功能。
函数重载格式：返回类型 operater运算符号(参数列表){实现语句;reture 类型;}
友元运算符重载：在类中 friend返回类型 operater运算符号(参数列表)
在complex类中声明友元函数friend complex operater+(const complex &a,const complex &b);
complex operater+(const complex &a,const complex &b)
{ complex temp;
temp.real = a.real+b.real;temp.image = a.image+b.image;return temp; }

成员运算符重载：在类中直接重载运算符函数
complex operater+( const complex &b)
{ complex temp;
temp.real = this->.real+b.real; temp.image = this->image+b.image; return temp; }

<<运算符重载：只能使用友元函数重载
格式：ostream & operater<<( ostream &别名,const 类对象)
istream & operater>>( istream &别名,类对象)
实现：先在类中声明友元，然后
ostream & operater<<( ostream &别名,const 类对象[不要用引用]){
cout[或别名]<<b.real<<”+”<<b.image<<endl;
return 别名;}

++运算符重载：complex operater++() //前置实现++a
{ this->real++; this->image++; return *this; }

		  complex operater++(int)		//后置实现a++

{ complex temp = *this;
this->real++; this->image++; return temp; }
=运算符重载：只能使用成员函数重载
complex operater=(const complex &c)
{ this->real = c.real; this->image = c.image; return *this;}
==运算符重载：返回值是bool类型true或false

继承和派生：class A public [private or protected] B{} //父类中的private成员不能被继承继承方式不同，子类得到的类成员封装属性不同一般使用public继承

初始化列表：若派生类要调用基类带参数构造函数或基类只有带参数的构造函数，则需要初始化列表
格式：student(string n, int a, int g):Person(n,a)/基类构造函数/ {grade = g;/派生类只定义了grade/} //派生类初始化构造函数调用基类构造函数
多继承：格式class 继承方式基类1,继承方式基类2{ … }

查看全文

http://www.xdnf.cn/news/3883.html