类和对象【超详细】

预学先知

①面向对象和面向过程的初步认识
C语言是面向过程，关注的是过程，分析步骤，利用函数调用解决问题
C++是基于面向对象的，关注的是对象，将一件事拆成不同的对象，靠对象的交互完成
例子：
设计一个快递系统
面向过程：关注实现下单，信息整合，送单的过程，体现到代码–方法/函数
面向对象：关注实现类对象及类对象之间的关系，快递员，商家，用户之间的关系 --类的设计及类之间的关系

②C++是基于面向对象：面向过程和面向对象混编。
原因：C++兼容C
然而JAVA是纯面向对象：只有面向对象

③C++对结构体进行了升级
一方面struct 在C++中升级成了类
C++类跟结构体不同的是除了可以定义变量，还可以定义方法/函数

#include
#include
#include
#include
using namespace std;

//struct/class
//C++兼容C中结构体的用法
//同时Struct在c++中升级成了类
//C++在类中还可以定义方法/函数
struct Student {
	//成员变量
	char _name[10];
	int _age;
	int _id;

	//成员方法
	void Init(const char* name, int age, int id) {//避免冲突，将前面改成_
		strcpy(_name, name);
		_age = age;
		_id = id;
	}
	void Print() {
		cout << _name << " " << _age << " " << _id << endl;
	}
};
int main() {
	struct Student s1 = {"xpc",18,7};//兼容C
	Student s2 = {  };  //升级成为类，Student是类名，也是类型
	
	s1.Print();
	s2.Init("zkx", 20, 11);
	s2.Print();
	return 0;
}

类和对象 1.类的访问限定符

了解class 和 struct 定义的区别，class 里面成员变量默认是私有的，而struct默认是公有(public)

最好不要使用默认限定，自己定义private和public（访问限定符）
我们来定义第一个类~
封装是一种更好的管理模式
①数据和方法都封装到类里面
②可以给你访问定义成共有，不想给你访问定义成私有或者保护
不封装是一种自由管理

class Student {
private:
	//成员变量
	char _name[10];
	int _age;
	int _id;
public:
	//成员方法
	void Init(const char* name, int age, int id) {//避免冲突，将前面改成_
		strcpy(_name, name);
		_age = age;
		_id = id;
	}
	void Print() {
		cout << _name << " " << _age << " " << _id << endl;
	}
};
int main() {
	struct Student s1; //兼容C
	Student s2;  //升级成为类，Student是类名，也是类型
	
	return 0;
}

注意，如果加了inline或者直接在类内定义（10几行内），编译器可能将这个方法当成内联函数处理

2.类的作用域

类定义了一个域

3.类大小的计算

只保存成员变量，成员函数放在公共代码区

为什么成员函数不放进来计算？
原因：每个对象中都有独立的成员变量，不同对象调用成员函数，调的是同一个，没有必要每个对象都保存一份

结论：计算类和类对象的大小，只看成员变量，考虑内存对齐，C++内存对齐规则跟C语言一致

另外，空类会给1byte，不存储有效数据，只是为了占位表示对象的存在
sizeof 类算出的是实例化对象的大小，而不是类是多大

补充C语言的内存对齐规则

4.this指针

既然成员方法不保存在类的实例对象内，那这些不同的对象调用同样的方法为什么会取得他们各自的值？？
那是因为省略了隐藏的this指针！

①调用成员函数时，不能显示传实参给this
②定义成员函数时，也不能显示声明形参this
③在成员函数内部，我们可以显示使用this

问题1：this是存在哪的？
一般情况下是存在栈（形参），有些编译器会放到寄存器中，如VS2019，ecx
问题2：

这道题选C
如果有人觉得是空指针错了，那不行，空指针是运行时错误，编译是检查不出来的

问题3：

选B

5.默认成员函数

1.构造函数

不然既有全缺省又有无参，语法上可以同时存在，但是如果同时存在，就会产生二义性

class Date {
public:
	
	
	//推荐使用全缺省或者半缺省，比较好用
	Date(int year = 2022, int month = 2, int day = 8) {
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {
	Date d1;
	Date d2(2022);
	Date d3(2022, 1);
	Date d4(2022, 1, 15);

	return 0;
}

C++把类型分成两类：内置类型（基本类型），自定义类型
内置类型：int/char/double/指针/内置类型数组等
自定义类型：struct/class定义的类型

我们不写编译器默认生成构造函数，对于内置类型不做初始化处理
对于自定义类型成员变量会去调用它的默认构造函数（不用参数就可以调的）初始化
如果没有默认构造函数就会报错
任何一个类的默认构造函数就是–不用参数就可以调用
有三个，全缺省，无参，我们不写编译器默认生成的

总结：C++我们不写编译器默认生成构造函数，设计得不好，没有对内置类型和自定义类型统一处理
不处理内置类型的成员变量，只处理自定义类型成员变量

#include
#include
#include
#include
using namespace std;


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

class Date {
public:

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

int main() {
	Date d1;
	

	return 0;
}

构造函数本质用来初始化

构造函数的初始化列表
用：和，分割
弄懂声明和定义：声明是一种承诺，没有实现，没有开空间，类型+变量属于是声明，定义是要开空间，要给值

C++建议在初始化列表内初始化
内置类型的成员，在函数体和在初始化列表都可以的，
自定义类型的成员，建议在初始化列表初始化，这样更高效

一道选择题

声明顺序就是初始化顺序
建议：初始化的顺序就是上面写的顺序，这样就不会出错

2.析构函数

构造的顺序一定是s1再s2 , 析构的顺序是相反的

class Stack {
public:
	Stack(int capacity = 4) {
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr) {
			cout << "malloc failn" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	void push() {

	}

	~Stack() {
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	int* _a;
	size_t _top;
	size_t _capacity;
};


int main() {
	
	Stack s1 ;
	Stack s2(20);

	return 0;
}

一个选择题

构造顺序是C A B D
C是全局变量，构造在main函数之前
D是静态变量，定义在局部，范围在局部，但是生命范围是全局

析构顺序是 B A D C
出了作用域，局部的变量先析构
D是局部的静态的比c先析构
局部变量是相反的，因为在栈中
全局变量是最后销毁的

范围相同的情况下，先定义的后析构，后定义的先析构

3.拷贝构造函数

为什么要传引用
调用拷贝构造，需要先传参数，传值传参又是一个拷贝构造

默认构造的拷贝函数可以对简单的数据类型进行拷贝

总结：拷贝构造不写生成的默认拷贝构造函数，对于内置类型和自定义类型都会拷贝处理。但是处理细节是不一样的，这个跟构造和析构是不一样的

传值传参会有一次拷贝构造
传值返回也会有一次拷贝构造

按理这个过程应该是三次，答案却只有两次
一次调用里面，连续构造函数，会被编译器优化，合二为一
直接把零时变量省略了，直接给值

必须要连续，接下来这种情况就不能优化

如果是匿名对象，也会优化，合二为一

6.运算符重载

定义在类的外面，private权限要打开

#include
using namespace std;

class Date {
public:
	Date(int year = 0, int month = 1, int day =1) {
		_year = year;
		_month = month;
		_day = day;
	}
//private:
	int _year;
	int _month;
	int _day;
};
//传引用消耗小，传const可以保护等
bool operator>(const Date& d1, const Date& d2) {
	if (d1._year > d2._year) {
		return true;
	}
	else if (d1._year == d2._year && d1._month > d2._month) {
		return true;
	}
	else if(d1._year == d2._year && d1._month == d2._month&&d1._day>d2._day){
		return true;
	}
	else
	{
		return false;
	}
}


int main() {
	Date d1(2022, 2, 12);
	Date d2(2022, 2, 9);
	cout<<(d1 > d2)< 
在类的内部 
#include
using namespace std;

class Date {
public:
	Date(int year = 0, int month = 1, int day =1) {
		_year = year;
		_month = month;
		_day = day;
	}
	//bool operator>(Date* const this,const Date& d) {
		
	bool operator>(const Date& d) {
		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;
		}
		else
		{
			return false;
		}
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {
	Date d1(2022, 2, 12);
	Date d2(2022, 2, 9);
	cout<(d2)< 

 
 总结一下：默认生成这四个默认成员函数
 构造和析构处理机制是基本类似的
 拷贝构造和赋值重载处理机制是基本类似的 
区分拷贝构造和赋值重载 
7.实现日期类 
头文件Date.h 
#pragma once

#include
using namespace std;

class Date {
public:
	Date(int year = 0, int month = 1, int day = 1);
	void Print();
	int GetMonthday(int year, int month);

	bool operator>(const Date&);
	bool operator<(const Date&);
	bool operator>=(const Date&);
	bool operator<=(const Date&);
	bool operator==(const Date&);
	bool operator!=(const Date&);

	//计算过n天以后是哪一天
	//+=改变原来 +不改变
	Date& operator+=(int day);
	Date operator+(int day);

	Date& operator-=(int day);
	Date operator-(int day);


	//前置++ 
	//++d1
	Date& operator++();

	//d1++:后置++为了跟前置区分，增加占位
	Date operator++(int);

	//计算两个日期之间的天数
	int operator-(const Date & d);

	//计算某一天是星期几
	void PrintWeekDay();

private:
	int _year;
	int _month;
	int _day;
};
 
源文件Date.cpp 
#include "Date.h"

void Date::PrintWeekDay() {
	const char* arr[] = {"星期一","星期二" ,"星期三" ,"星期四" ,"星期五" ,"星期六" ,"星期日"};
	Date d1(1900, 1, 1);//1900年一月一是星期一
	int day =*this-d1;//膜完范围0~6 对应周一到周日
	cout << arr[day % 7] << endl;
}

int Date::operator-(const Date & d) {
	Date max = *this;
	Date min = d;
	int count = 0;
	int flag = 1;

	if (max < min) {
		max = d;
		min = *this;
		flag = -1;
	}

	while (min != max) {
		++min;
		++count;
	}
	return count * flag;
}


//所有的类的比较都可以使用 复用 这种方法
bool Date::operator>(const Date& d) {
	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;
	}
	else
		return false;
}
// < 就是 >= 取反
bool Date::operator<(const Date& d) {
	return !(*this >= d);
}


//复用操作
bool Date::operator>=(const Date& d) {
	return *this > d || *this == d;
}


bool Date::operator<=(const Date& d) {
	return !(*this > d);
}

bool Date::operator==(const Date& d) {
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}
bool Date::operator!=(const Date& d) {
	return !(*this == d);
}



//建议使用前置++
//这里是前置++
Date& Date::operator++() {
	*this += 1;
	return *this;
}
 
//这里是后置++
Date Date::operator++(int) {
	Date ret(*this);
	*this += 1;
	return ret;
}

Date& Date::operator-=(int day) {
	if (day < 0) {
		return *this += -day;
	}

	_day -= day;
	while (_day<=0) {
		_month -= 1;
		if (_month == 0) {
			_year -= 1;
			_month = 12;
		}
		_day += GetMonthday(_year, _month);
	}
	return *this;//返回后this还存在，就可以使用引用
}


Date Date::operator-(int day) {
	Date ret(*this);
	ret -= day;
	return ret;
}


Date& Date::operator+=(int day) {
	_day += day;
	while (_day >= GetMonthday(_year, _month)) {
		_day -= GetMonthday(_year, _month);
		_month =_month+ 1;
		if (_month == 13) {
			_month = 1;
			++_year;
		}
	}
	return *this;
}

Date Date::operator+(int day) {
	Date ret(*this);
	//ret._day += day;
	ret += day;
	return ret;
}

void Date::Print() {
	cout << _year << "-" << _month << "-" << _day << endl;
}

int Date::GetMonthday(int year, int month) {

	int Month[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)&&month==2) {
		Month[2] += 1;
	}
	return Month[month];
}

Date::Date(int year, int month, int day) {
	_year = year;
	_month = month;
	_day = day;

	//判断当前日期是否合法
	if (!((year >= 0) && (month > 0 && month < 13) && (day > 0 && day <= GetMonthday(year, month)))) {
		cout << "该日期不合法，错误日期是->";
		Print();
	}
}


 
源文件Test.cpp 
#include "Date.h"

//查询日期是否合法
void Test1() {
	Date d1(2022, 2, 21);
	Date d2(2022, 2, 41);
	d1.Print();
	d2.Print();
}

//计算n天过后是哪一天
void test2() {
	Date d1(2022, 2, 21);
	d1 += 100;
	d1.Print();

	Date d2(2022, 2, 22);
	d2 + 100;
	d2.Print();
	//前置++和后置++
	Date d3 = d1++;//d1.operator(&d1,0)
	Date d4 = ++d2;//d2.operator(&d2)
	d3.Print();
	d4.Print();

}

void test3() {
	Date d1(2022, 1, 1);
	d1 += 10;
	d1.Print();
	Date d2 = d1 - 20;
	d2.Print();
	d2 -= 10;
	d2.Print();

	Date d3;
	d3 =d2  - -100;
	d3.Print();
	d3++;
	d3.Print();
}

void test4() {
	Date d1(2022, 2, 2);
	Date d2(2022, 1, 2);
	int day1 = d1 - d2;
	cout << day1 << endl;
	int day2 = d2 - d1;
	cout << day2 << endl;
	d1.PrintWeekDay();

}
int main() {
	//test2();
	test4();

	return 0;
}
 
8.const 修饰的成员 

 C++解决的方法，在后面加一个const
 
 
 总结：成员函数加const是好的，建议能加const都加上，这样普通对象和const对象就都可以调用了。
 但如果要修改成员变量的成员函数是不能加的，比如日期类中的 += ++等等实现 
9.友元 

 就像黄牛，能不用就不用
  
案例引入
 因为不能实现cout<<对象，于是我们要完成对cin，cout的重载
 但普通的重载方式不可行
 如果是双操作数的运算符重载，第一个参数是操作数，第二个参数是右操作数
 
 于是我们引入friend有元，放入类中加入friend
 
 
 
 友元类
  
#include
using namespace std;

//你是我的朋友，你就可以在你的类中访问我的私有属性
//但你是我的朋友，我不一定是你的朋友，和关注的概念是一样的
class T {
	friend class Date;
public:
	T(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 =1,int month =1 ,int day =1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

	void SetTimeDate(int hour, int minute, int second) {
		_time._hour = hour;
		_time._minute = minute;
		_time._second = second;
	}
private:
	int _year;
	int _month;
	int _day;
	T _time;
};
 
10.explict关键字 
用了explicit 编不过，不用可以使用，是C++默认的一种“潜规则” 
#include
using namespace std;

class Date {
public:
	
	Date(int year)
		:_year(year)
	{
		cout << "Date(int year)" << endl;
	}

	Date(const Date& d) {
		cout << "Date(const Date& d) " << endl;
	}
	
private:
	int _year;
	int _day;
	int _month;
};

int main() {
	//虽然他们两个都是直接构造，但是过程是不一样的
	Date a(2022);
	Date b = 2022;//隐式类型转换
	//本来用2022构造一个临时对象Date（2022），再用这个对象拷贝构造b
	//但是C++编译器在连续的以恶搞过程中，多个构造会被优化，合二为一
	//所以这里被优化为直接是一个构造


	//隐式类型转换 -相近类型 --表示意义相似的类型
	double d = 1.1;
	int i = d;
	const int& i2 = d;

	//强制类型转换 - 无关类型
	int* p = &i;
	int j = (int)p;

	return 0;
}
}
 
11.static 成员 
可以叫静态成员变量，静态成员函数 
#include
using namespace std;

class A {
public:
	A(int a = 0)
		:_a(a)
	{
		++_scount;
	}

	A(const A& aa)
	:_a(aa._a)
	{
		++_scount;
	}

//静态可以保护，静态不能滴哦用_a
	static int GetCount() {
		return _scount;
	}

private:
	int _a;
	static int _scount;
};
int A::_scount = 0;

void f(A a)
{

}
int main() {
	A a;
	f(a);
	cout << a.GetCount() << endl;

	return 0;
}
 

  
12.C++11 
#include
using namespace std;

class B
{
public:
	B(int b = 0)
		:_b(b)
	{}
private:
	int _b;
};

//C++ -- 打补丁
class A 
{
public :
	A() {

	}
private://这里并不是初始化（是给具体某个空间初始化），因为这里式声明
	int _a1 = 0 ;//这里给成员变量省略值
	B _bb1= 10;
	B _bb2 = B(20);
	//static int _scount = 0;不能这样写，不能给缺省，缺省是给构造函数用的，构造函数不处理静态的成员
	//静态的不能给缺省，要在类外面全局初始化
};

int main() {
	A aa;

	return 0;
}
 
13.内部类 

 算一算sizeof A 是多大
 答案是8
 B和A完全是一样的，只不过收到A的约束
 B中可以访问A的私有，但是A不能访问B的私有

类和对象【超详细】

C/C++/C#相关栏目本月热门文章