c++之一键总结（二）

以你之姓@ 2022-04-23 13:28 128阅读 0赞

1，类的学习：

void show() {
    }; //一般函数声明
    struct Student
    {
    	//成员变量/成员对象
    	int id;
    	string name;
    	int score;
    	//成员函数/成员方法
    	void show() {
    	//	this->show();  //递归
    	//	show(*this); //不是调用自己,语法错误
    		cout << "s.show() " << endl;
    		cout << id << " " << name << " " << score <<     endl;
    	}
    	void show(Student s) {
    		cout << "s.show(s) " << endl;
    		cout << s.id << " " << s.name << " " << s.score << endl;
    		cout << id << name << score << endl;
    	}
    	void show(int id) {
    		cout << id << " " << name << " " << score <<     endl;
    	//this 是一个指向本对象的指针 this == &s1，this是一个只想自己类的指针。
    	//C++为成员函数提供了一个名字为this的指针，这个指针称为自引用指针							 
    	//	this = new Student; 错误, 不能换指向
    	// Student const* this = &s1;
    		cout << this->id << " " << name << " " << score <<     endl;
    	} 
    	void show(Student* const self) {
    	//	self = new Student;
    		cout << "*" << endl;
    		cout << self->id << " " << self->name << " " << self->score << endl;
    	}
    };
    void show(Student s) 
    {
    	cout << s.id << " " << s.name << " " << s.score << endl;
    }

2，类的初始化问题

struct Person
    {
    	int id;
    	string name;
    	string sex;
        void init(int id, string name, string sex) {
    		this->id = id;
    		this->name = name;
    		this->sex = sex;
    }
    //添加构造函数
     Person(int i =0; string n="lily",string s="male")
    {
    	    id = i;
    	    name = n;
    	    sex = s;
    }
    }；
    调用：Person p1;
              p1.init(1001, "Tom", "male");

3,关键字说明总结

（1）class关键字定义的类，默认权限全部是私有的，struct 默认权限全部是公有的
    （2）如果成员是私有的，不能这样直接初始化Person p1 = {1000, "An", "female"};
    	      而要用p1.init(1001, "Tom", "male");
    protected: （1）受保护的，本类内和它的派生类可以访问
    		          （2）外部不可访问
    private:   （1）只能在类内直接访问
                   （2）类内的成员函数不区分先后顺序, 不需要先声明才能使用
    public:  （1）类内和类外都能访问
    
    （1）explicit 阻止隐性的类型转换
    （2）final 加在类后面表示一个类不能再被继承
    例：class D /*final*/ : public Base  //如果有final 就不能继承public Base
    （3）final 在函数后面表示一个函数不能被重写  ,final关键字的作用是使派生类不可覆盖它所修饰的虚函数
      例：void show() final override //这个函数是重写的, 如果不是前面基类有虚函数，编译override会报错
    
    例：

4，类的构造学习

class Person
    {
    	int id;
    	string name;
    	int age；
    	int * score;
    public:
    	//拷贝构造函数，与类名完全相同，没有返回值, 用来初始化对象, 在定义对象的时候被调用
    	Person(int i, string n, int a) {
    		id = i;
    		name = n;
    		age = a;
    		score = new int(0); 如果不写析构函数，会有默认的析构函数产生
    		//析构函数，销毁对象, 离开作用域之后自动调用
    	   //析构顺序和构造顺序相反
    	}
    	//不写任何构造函数的情况下，会产生默认的无参构造函数
    	Person() {
    		id = 0;
    		age = 0;
    	}
    	//委托构造
      Person(int i, string n, int a) :id(i),name(n),age(a)
      {
      }
    	void init(int i, string n, int a) {
    		id = i;
    		name = n;
    		age = a;
    	}
    	void show() {
    		cout << id << " " <<name << " " << age << endl;
    	}
    	Person getSelf() {
    		return *this;
    	}
    	int getNum() {
    		int a = 10; 
    		return a;  //2, 把a的值传出去 
    				   //3, a离开作用域，被销毁
    	}
    	//直接引用id这个对象，不会产生匿名对象
    	int& getNum2() {
    		return id;
    	}
    //	左值			右值
    //	local-value  read-value
    	//变量		//	常量 匿名变量
    //	p1.getNum() = 10;	错误，给匿名变量赋值
    //	p1.getNum2() = 10;	正确，给id
    ~Person()
    {
       delete this->score; //调用完析构函数之后，才会释放本对象的内容, scorte本身
    }

5，运算符重载和友元函数

class Integer
    {
    	int* num;
    public:
    	mutable int sum;	//mutable 定一个变量是可变的
     	const int n;//mutable 定一个变量是可变的
    	Integer() {
    		num = new int(0);
    	}
    	Integer(int n) {
    		num = new int(n);
    	}
    	Integer(const Integer& i) {
    		num = new int(i.getNum());
    	//	num = new int(*i.num);
    	}
    	~Integer() {
    		delete num;
    	}
    	//在成员函数的后面加const, 意思是这个函数不能改变类的成员变量
    	//const成员函数可以重载
    	int getNum() const {
    	//	num = new int(12);
    	//	sum = 12;
    		cout << "const " << endl;
    		return *num;
    	}
    	//const 加在前面，意思是返回值是const的
    	const int getNum() {
    		cout << "non - const " << endl;
    		return *num;
    	}
    	void setNum(int n) {
    		*num = n;
    	}
    };
    /*	只有成员函数可以加const属性
    int fun() const 错误
    {
    }
    */

运算符重载  
1 运算符重载，操作数必须至少有一个自定义的类型,　为了阻止用户更改基本数据运算规则  
2 不能改变操作符本身的特性, 不能将二元运算符改成三元运算符, 优先级不能改变  
3 不能创建新的运算符 \` ￥  
4 有的运算符不能重载, sizeof() , ?: .  
5 大多数运算符可以在类内重载，也可以在类外重载 + ==  
有的必须在类外重载 >> <<  
有的必须在类内重载 下标运算符：= \[\] 调用运算符： () -> \* ++ –

struct Date
    {
    private:
    	int year, month, day;
    	bool ok;
    public:
     //添加构造函数
    	explicit Date(int y=0, int m=1, int d=1) {
    		year = y;
    		month = m;
    		day = d;
    		ok = isOk();
    	}
    	void show() {
    		if (ok)
    			cout << year << "/" << month << "/" << day << endl;
    		else
    			cout << "日期错误" << endl;
    	}
    	/****************************更新日子********************************************/
    	bool updateOneDay() {
    		if (!ok) {
    			cout << "日期错误，不能+1" << endl;
    			return false;
    		}
    		if (day == maxDay() && month == 12) {
    			day = 1;
    			month = 1;
    			year++;
    		} else if (day == maxDay()) {
    			day = 1;
    			month++;
    		} else 
    			day++;
    		return true;
    	}
    private:
    	//类内的成员函数不区分先后顺序, 不需要先声明才能使用
    	/****************************求每个月的最大天数********************************************/
    	int maxDay() {
    		if (month == 4 || month == 6
    				|| month == 9 || month == 11)
    			return 30;
    		else if (month == 2 && isLeap())
    			return 29;
    		else if (month == 2 && !isLeap())
    			return 28;
    		else 
    			return 31;
    	}
    	/****************************求闰年********************************************/
    	bool isLeap() {
    		return year%4==0 && year%100!=0 || year%400==0;
    	}
    	bool isOk() {
    		if (month < 1 || month > 12)
    			return false;
    		if (day < 1 || day > maxDay()) 
    			return false;
    		return true;
    	}
    public:
    /****************************操作符的重载********************************************/
    	Date operator-(int n) {
    		Date t;//(0, 1, 1);
    		t.year = year;
    		t.month = month;
    		t.day = day - n;
    		t.ok = t.isOk();
    		return t;
    	}
    	Date operator-(const Date& d) {
    		Date t;
    		t.year = year - d.year;
    		t.month = month - d.month;
    		t.day = day - d.day;
    		t.ok = t.isOk();
    		return t;
    	}
    	Date operator+(int n) {
    		Date t;//(0, 1, 1);
    		t.year = year;
    		t.month = month;
    		t.day = day + n;
    		t.ok = t.isOk();
    		return t;
    	}
    
    	Date operator+(const Date& d) {
    		cout << "类内的+ " << endl;
    		Date t;
    		t.year = year + d.year;
    		t.month = month + d.month;
    		t.day = day + d.day;
    		t.ok = t.isOk();
    		return t;
    	}
    	/*******************************************************************************************/	
    	/****************************默认的函数: 无参构造，拷贝构造，析构，=********************************************/
    	Date& operator=(const Date& d) {
    		cout << "operator = " << endl;
    		year = d.year;
    		month = d.month;
    		day = d.day;
    		ok = d.ok;
    		return *this;
    	}
    	Date(const Date& d) {
    		cout << "copy " << endl;
    		year = d.year;
    		month = d.month;
    		day = d.day;
    		ok = d.ok;
    	}
    	Date& operator-=(int n) {
    		day -= n;
    		ok = isOk();
    		return *this;
    	}
    	Date& operator-=(const Date& d) {
    		year -= d.year;
    		month -= d.month;
    		day -= d.day;
    		ok = isOk();
    		return *this;
    	}
    	/*******************************************************************************************/	
    	/****************************算数，关系，位，逻辑********************************************/
    	bool operator==(const Date& d) {
    		cout << "类内的== " << endl;
    		return year == d.year && 
    			month == d.month &&
    			day == d.day;
    	}
    	bool operator!=(const Date& d) const {
    		return !(*this == d);
    	}
    	bool operator>(const Date& d) const {
    		if (year > d.year)
    			return true;
    		else if (year == d.year && month > d.month)
    			return true;
    		else if (year == d.year && month == d.month && day > d.day)
    			return true;
    		return false;
    	}
    	bool operator<(const Date& d) const {
    	//	return !(*this > d || *this == d);
    		return d > *this;
    	}
    	/*******************************************************************************************/	
    	//前加加	operator++()
    	Date& operator++()
    	{
    		year++;
    		month++;
    		day++;
    		return *this;
    	}
    	//后加加 固定写法 operator++(int)
    	Date operator++(int) 
    	{
    		Date t = *this;
    		year++;
    		month++;
    		day++;
    		return t;
    	}
    	int getY() const {
    		return year;
    	}
    	int getM() const {
    		return month;
    	}
    	int getD() const {
    		return day;
    	}
    	/*******************************友元函数（类内定义，类外实现）*******************************/
    	friend ostream& operator<<(ostream& out, const Date& d);
    	friend istream& operator>>(istream& in, Date& d);
    	//在类内声明一个函数是类的友元函数，这个函数可以访问类的私有成员
    	friend Date operator+(const Date& d1, const Date& d2);
    	friend Date& operator+=(Date& d1, const Date& d2);
    	friend bool operator==(const Date& d1, const Date& d2);
    };
    
    /*
    d1 + d2 ; 
    d1.operator+(d2)
    operator+(d1, d2);
    */
    //输入运算符重载(stream std::cin )
    istream& operator>>(istream& in, Date& d)
    {
    	in >> d.year >> d.month >> d.day;
    	return in;
    }
    //输出运算符重载(stream std::cout )
    ostream& operator<<(ostream& out, const Date& d) {
    //	out << d.getY() << "/" << d.getM() << "/" << d.getD();
    	cout << d.year << "/" << d.month << "/" << d.day;
    	return out;
    }
    	/*******************************（类外成员函数定义）*******************************/
    Date& operator+=(Date& d1, const Date& d2) {
    	cout << "类外的+= " << endl;
    	d1.year += d2.year;
    	d1.month += d2.month;
    	d1.day += d2.day;
    	return d1;
    }
    bool operator==(const Date& d1, const Date& d2) {
    	cout << "类外的== " << endl;
    	return d1.year == d2.year && 
    			d1.month == d2.month &&
    			d1.day == d2.day;
    }
    Date operator+(const Date& d1, const Date& d2) {
    	cout << "类外的+ " << endl;
    	Date t;
    	t.year = d1.year + d2.year;
    	t.month = d1.month + d2.month;
    	t.day = d1.day + d2.day;
    	return t;
    }

6，静态成员和静态函数

class Person
    {
    	string name;
    	int age;
    public:
    	int id;
    	Person(string n="--", int a=0) : id(++count), name(n), age(a) 
    	{	}
    	//静态函数，没有this指针, 不能访问类的普通成员变量
    	//能访问静态成员变量
    	//同一个函数不能有静态和非静态两种版本
    	static int get() {
    		return count;
    	}
    	static int count;	//静态成员变量，整个类共用一个变量
    };
    //*必须在类外对静态成员进行全局的初始化
    int Person::count = 1000;//初始化

7，deflaut关键字的使用：

class Student
    {
    	int id;
    	string name;
    	//定义成私有的构造函数，也可以阻止构造对象
    //	Student(const Student& s) {}
    public:
    	Student(int i, string n) : id(i), name(n) {
    	}
    //	Student() {}		 //默认的构造函数
    	Student() = default; //default c++11 使编译器合成默认的构造函数
    	
    	//**默认的拷贝构造, 不写也有默认的**//
    	//Student(const Student& s) : id(s.id), name(s.name) {}
    	Student(const Student& s) = delete; //delete 编译器不合成拷贝构造
    	
    	//**默认的析构**//
    	//~Student() {}	析构函数*不要*写成delete函数, 如果析构函数是被删除的，对象就不会释放
    	~Student() = default;
    	
    	//**默认的赋值运算符**//
    	//Student& operator=(const Student& s) {
    	//  id = s.id; name = s.name; return *this;
    	//}
    	Student& operator=(const Student& s) = delete;
    
    	friend ostream& operator<< (ostream& out, const Student& s);  //输出的友元
    };
    
    ostream& operator<< (ostream& out, const Student& s) 
    {
    	out << s.id << " " << s.name;
    	return out;
    }