【C++】类和对象核心总结

//class Stack
struct Stack
{
	//类体，由成员函数和成员变量组成
	void Init(int N = 4)
	{
		top = 0;
		capacity = 0;// 访问限定符限制的是类外面的，类里面不会被限制
	}
	void Push(int x)
	{

	}
	int* array;
	int top;
	int capacity;//C++把类看作一个整体，编译器搜索的时候会在整个类里面去搜索。C语言为了编译的效率只会向上搜索。
};//不要丢掉分号
int main()
{
	Stack st;// 用类stack实例化出对象st
	st.top = 0;//这里的语句，在class类会被限制 struct类不会被限制
}

//使用时，要指定类域
class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout << _name << " " << _gender << " " << _age << endl;
}

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int  _age;
};

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int  _age;
};

class A
{
public:
	void PrintA()
	// 从操作系统角度来看，不可能把所有的指令都存下来，只存函数的地址，指针大小4个字节，所以大小应该是5个字节，内存对齐就是8个字节
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	cout << sizeof(A) << endl;
}

class A
{

};
int main()
{
	cout << sizeof(A) << endl;
}

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;//使用this指针访问到对象的成员变量_year
		_month = month;
		_day = day;
	}
	
	void Print()// 在函数体内部我们可以使用this指针。
	{
		cout << this << endl;
		cout << this->_year << "-" << this->_month << "-" << _day << endl;//我们加了this，编译器就不加了，我们不加，编译器就会加
	}
private:
	int _year;     
	int _month;    
	int _day;     
};
int main()
{
	Date d1;
	d1.Init(2022, 12, 15);

	Date d2;
	d2.Init(2022, 12, 16);

	d1.Print();//d1调用，访问的就是d1的成员
	d2.Print();//d2调用，访问的就是d2的成员

	cout << &d1 << endl;
	cout << &d2 << endl;
	return 0;
}

class A
{
public:
	void Print()
	{
		cout << "Print()" << endl;
		// 不发生空对象的成员访问，对象中不存在成员函数，成员函数都被转换成二进制指令放在代码段里面了
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}
class B
{
public:
	void PrintB()
	{
		cout << _a << endl;
		// 你实例化出来的对象是空的，然而你又通过指针去访问空对象中的数据，那就是典型的空指针访问，this->_a，读取访问权限冲突
		
	}
private:
	int _a;
};
int main()
{
	B* p = nullptr;
	p->PrintB();
	return 0;
}

 class Date
 {
  public:
	 /*
	 // 如果用户显式定义了构造函数，编译器将不再生成
	 Date(int year, int month, int day)
	 {
	 _year = year;
	 _month = month;
	 _day = day;
	 }
	 */
 
 void Print()
	 {
	 cout << _year << "-" << _month << "-" << _day << endl;
	 }
  
  private:
	 int _year;
	 int _month;
	 int _day;
 };
  
  int main()
 {
 	 Date d1;
	 return 0;
 }

class Date
{
private:
	 // 基本类型(内置类型)
	 int _year = 1970;
	 int _month = 1;
	 int _day = 1;
	 // 自定义类型
	 Time _t;
};

class Stack
{
public:
	Stack(int capacity = 4)
	{
		//iostream可能间接包含C语言中的头文件
		_array = (int*)malloc(sizeof(int) * capacity);//他妈的这里开辟了一个随机数大小的空间我真服了。
		if (_array == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_array);
		_array = nullptr;
		_top = _capacity = 0;
	}

	
	void Push(int x)
	{
		_array[_top++] = x; 
	}
private://如果我们想要在调试窗口看到对象的成员变量，可以敲个this指针，这样就可以看到对象的全部成员变量
	int* _array;
	int _top;
	int _capacity;
};

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
	 _year = year;
	 _month = month;
	 _day = day;
 }
 // Date(const Date& d)   // 正确写法
    Date(const Date d)   // 错误写法：编译报错，会引发无穷递归
 {
	 _year = d._year;
	 _month = d._month;
	 _day = d._day;
 }
private:
	 int _year;
	 int _month;
	 int _day;
};
int main()
{
	 Date d1;
	 Date d2(d1);
	 return 0;
}

int main()
{
	Date d1(2022, 12, 16);
	Date d3(2022, 12, 12);
	// 例如我想拷贝一份d1

	Date d2(d1);// 拷贝构造
}

//bool operator==(Date* this, const Date& d2)
bool operator==(const Date& d)//这里用传值传参不好，因为值拷贝要调用拷贝构造，而且比较里面不会改变对象，所以要用const修饰
	{
		//成员变量是私有的，我们怎么解决呢？
		//放到类里面由于this指针的存在，导致参数过多，因为这个函数只允许两个参数存在
		return d._year == _year &&
			d._month == _month &&
			d._day == _day;
	}
//上面是类域的运算符重载，下面是全局域的运算符重载。差别就是非静态成员函数有this指针
bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year &&
        d1._month == d2._month &&
        d1._day == d2._day;
}
int main()
{
	cout << (d1 == d2) << endl;// d1为左操作数，默认的运算符重载的this指向的就是d1
}

#include <iostream>
using namespace std

//写在Date类的形式：

void operator<<(ostream& out)//两个对象，cout和d1
{
	out << _year << "年" << _month << "月" << _day << "日" << endl;
}
//调用时的形式：
int main()
{
	d1<<cout;// 相当于d1.operator<<(cout)
	return 0;
}


//写在全局的形式
class Date
{
	//友元声明（类的任意位置，不用加inline），我是你的朋友，我来偷你家🍑桃子了，你别放狗咬我。
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
	//利用友元便可以解决类外函数无法访问到类内私有成员变量的问题。
	//………………………………省略一部分Date类的内容
}
// operator<<(cout,d1)  cout<<d1
inline ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;//成员是公有的才可以这么用，私有需要友元来解决
	return out;
}

inline istream& operator>>(istream& in, Date& d)
{	
	in >> d._year >> d._month >> d._day;
	return in;
}

void DateTest4()
{
	Date d1, d2;
	
	cout <<d1;// 相当于 cout.operatotr<<(d1)，这样的形式调用，重载必须写在全局
	cin >> d1;
	cout << d1 << d2 << endl;// 调用我们自己写的运算符重载 void operator<<(cout,d1)
	
	//endl可以不用重载，因为endl是内置类型，其实就是字符'\n'
	cout << d1 - d2 << endl;
	
}
int main()
{
	DateTest4();
	return 0;
}

class Date
{ 
// …………………………省略Date类的部分内容
public :
Date& operator=(const Date& d)
 {
     if(this != &d)
     {
         _year = d._year;
         _month = d._month;
         _day = d._day;
     }
      return *this;
 }
// …………………………省略Date类的部分内容
private:
	 int _year ;
	 int _month ;
	 int _day ;
};

typedef int DataType;
class Stack
{
public:
     Stack(size_t capacity = 10)
     {
         _array = (DataType*)malloc(capacity * sizeof(DataType));
         if (nullptr == _array)
         {
             perror("malloc申请空间失败");
             return;
         }
         _size = 0;
         _capacity = capacity;
     }
     void Push(const DataType& data)
     {
         // CheckCapacity();
         _array[_size] = data;
         _size++;
     }
     ~Stack()
     {
         if (_array)
         {
             free(_array);
             _array = nullptr;
             _capacity = 0;
             _size = 0;
         }
     }
private:
     DataType *_array;//向操作系统申请内存资源
     size_t _size;
     size_t _capacity;
};
int main()
{
     Stack s1;
     s1.Push(1);
     s1.Push(2);
     s1.Push(3);
     s1.Push(4);
     Stack s2;
     s2 = s1;
     return 0;
}

// C++
Date& Date:: operator++()
{
	_day += 1;

	return *this;// 出了作用域*this对象还在，因为是main栈帧里面的，所以可以用引用返回，这样可以减少调用拷贝构造
}

// C++规定后置++重载时，需要多一个int参数，主要是为了和前置区分开来，构成函数重载
Date Date:: operator++(int)
{
	Date tmp(*this);// 拷贝构造
	_day += 1;

	return tmp;// 返回++之前的值
}

class Date
{
public:
	Date* operator&()
	{
		//return this;
		return nullptr;
	}
	const Date* operator&()const// 这个地方的知识点可以先去看一下const成员的讲解，看完自然就可以理解，这里的函数为什么设计成这个样子。
	{
		//return this;
		return nullptr;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1;
	const Date d2;
	return 0;
}

class Date
{
public:

	void Print()const// 相当于const Date* const this，这样this指向的内容就是可读了，这里的const只修饰this指向的内容，其他参数不受影响
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};


void DateTest5()
{
	//看到const转换的错误什么的，大概率都是出现权限放大
	Date d1(2022, 12, 12);
	d1.Print();//可读可写 到 可读，权限缩小

	const Date d2(2022, 12, 18);
	d2.Print();//可读 到 可读可写，权限放大
	//d2是被const修饰的，说明对象本身不可被修改相当于const Date*或Date const*这样的指针形式

	//但类成员函数中的this指针又是Date* const this，至于为什么是这样子，
	//我们之前提到过，对象的地址是不应该被随意修改的，所以编译器将this参数默认为上述样子，
	//可以看到如果不想让权限放大，我们必须在*的前面加上const

	//由于this是隐形的，所以编译器规定在函数括号后面加const来表示此对象不可被修改。	
}
int main()
{
	DateTest5();
	return 0;
}

class Date
{
public:
	Date(int year, int month, int day)
	 {
	     _year = year;
	     _month = month;
	     _day = day;
	 }
private:
	int _year;
	int _month;
	int _day;
};

class Date
{
public:
	Date(int year, int month, int day)
		 : _year(year)// 初始化列表
	     , _month(month)
	     , _day(day)
	 {}
private:
	int _year;
	int _month;
	int _day;
};

class Date
{
public:
	Date(int year=2023,int month=1,int day=1)
		:_year(2024)
		,_month(1)
		,_day(1)
	{}

private:
	int _year = 2022;
	int _month = 12;
	int _day = 23;
};
int main()
{
	Date d1;

	return 0;
}

class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();// 答案：程序会输出1和随机值
}

class Date
{
public:

	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
	 // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
	explicit Date(int year)// 单参的构造函数支持了隐式类型转换
		:_year(year)
	{}
	
	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
	
	// explicit修饰构造函数，禁止类型转换
	 explicit Date(int year, int month = 1, int day = 1)//全缺省也可以，我们也可以只传一个参数
	 : _year(year)
	 , _month(month)
	 , _day(day)
	 {}
	 
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
 
	Date d1;//直接调用构造，下面多了一个临时变量的拷贝构造而已。	当然优化之后两个其实可以看作是一样的。
	// 隐式类型的转换
	Date d2 = 2022;// 用整型2022去构造一个Date类的临时对象，在用临时对象去拷贝构造d2，这里会直接优化为构造。	
	//            本来：构造+拷贝构造        优化：直接构造
	const Date& d5 = 2022;// 引用的是2022构造的临时对象，临时对象具有常性，所以需要用const修饰
	//             这里不会做优化，必须先构造再拷贝构造，因为他是引用
	
	return 0;//程序正常运行结束
}

class Date
{
public:
	// 多参数
	 Date(int year, int month , int day	)
		 : _year(year)
		 , _month(month)
		 , _day(day)
	 {}

	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1 = { 2022,12,18 };
	Date d2(2022, 12, 18);
	//上下写法等价，结果一样，但是过程不一样，一个是直接构造，一个是构造+拷贝构造

	const Date& d3 = { 2022,12,18 };// 引用的是临时变量，具有常性用const修饰

	//C++11也是延申了C++98里面的单参数构造。


	return 0;
}

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		++N;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		++N;
	}
	static int GetN()//  静态成员函数没有this指针,只能访问静态成员（变量或函数），静态无法访问非静态。
		//所以静态成员函数其实是和静态成员变量配合起来用的。
	{
		return N;
	}
private:
	int _a;

	// 类中的static成员变量属于类，并且类的每个对象是共享的
	static int N;//类里面的静态会受到类域的限制

	//所以现在有三种静态，全局静态，局部静态，类静态，他们生命周期都是全局的，但作用域是不同的
};


int A::N = 0; //静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

int main()
{
	//****  aa1和aa2是存在栈上的，类静态N是存在静态区(全局区)的

	A aa1(1);
	A aa2 = 2;//会不会出现构造呢？
	//编译器优化了，所以这里直接拷贝构造，如果不优化答案就应该是4.
	A aa3 = aa1;

	cout << aa1.GetN() << endl;
	cout << A::GetN() << endl;
	return 0;
}

class Time
{
   friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
 Time(int hour = 0, int minute = 0, int second = 0)
 : _hour(hour)
 , _minute(minute)
 , _second(second)
 {}
   
private:
   int _hour;
   int _minute;
   int _second;
};
class Date
{
public:
   Date(int year = 1900, int month = 1, int day = 1)
       : _year(year)
       , _month(month)
       , _day(day)
   {}
   
   void SetTimeOfDate(int hour, int minute, int second)
   {
       // 直接访问时间类私有的成员变量
       _t._hour = hour;
       _t._minute = minute;
       _t._second = second;
   }
   
private:
   int _year;
   int _month;
   int _day;
   Time _t;
};

 B类的访问受A的类域和访问限定符的限制
class A
{
private:
	int _a;
	static int k;

public: 
	class B // 内部类B天生就是A的友元
	{
		int _b;

		void foo(const A& a)
		{
			cout << k << endl;//内部类可以直接访问外部类中的static成员
			cout << a._a << endl;//通过A类对象访问A类中的成员变量。
		}
	};
};
int A::k = 1;
int main()
{
	cout << sizeof(A) << endl;
	// A中没有B，算的是单纯A的大小，仅仅只是嵌套定义
	A aa;
	A::B bb;

	return 0;
}

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};

int main()
{

	// 匿名对象 -- 生命周期是当前这一行
	A();//在这一行定义完之后，下面的无论哪行都无法用这个对象，并且立马会调用析构函数
	A(3);

	//Solution so;
	//so.Sum_Solution(10);
	// 这里创建so对象就只是为了调用函数，有点白白浪费。这时候可以用到匿名对象 

	Solution().Sum_Solution(10);//创建匿名对象调用函数

	return 0;
}

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
void f1(A aa)
{}
A f2()
{
	A aa;
	return aa;
}
A f3()
{
	return A(10);
}
int main()
{
	// 优化场景1
	A aa1 = 1;  //  A tmp(1)  +  A aa1(tmp) -->  优化 A aa1 = 1

	// 优化场景2
	A aa1;// 构造
	f1(aa1);// 拷贝构造

	f1(A(1));// 匿名构造+拷贝构造  -->  优化  构造（直接拿1去构造形参了）
	f1(1);// 隐式类型转换 匿名构造+拷贝构造  -->  优化  构造

	f2();// 构造 返回时候的拷贝构造也被优化了
	A ret = f2();// 构造+两次拷贝构造  优化为直接构造A ret

	A ret;// 拷贝构造
	ret = f2();// 构造+拷贝构造+赋值重载  直接优化为赋值重载

	A ret = f3();//本来是构造+两次拷贝构造 优化为直接构造对象ret

	return 0;
}