2021-07-31

C++面向对象的基本语法以及代码实现1
// c++第三次课.cpp : 此文件包含 “main” 函数。程序执行将在此处开始并结束。
//
//
//#include
//
//int main()
//{
// std::cout << “Hello World!\n”;
//}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧:
// 1. 使用解决方案资源管理器窗口添加/管理文件
// 2. 使用团队资源管理器窗口连接到源代码管理
// 3. 使用输出窗口查看生成输出和其他消息
// 4. 使用错误列表窗口查看错误
// 5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
// 6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

//第三次课
//计算结构体的大小
//规则；最终是默认对齐数和最大的成员的占用字节数
////#pragma pack(1)//这里是自己设定默认对齐数 这里设定的是1.
//#include
//using namespace std;
//struct A
//{
// int a;
// int b;
// double d;
// int e;
//
//};
//struct B
//{
// char a; //1+7
// double d ;//8
// //int c; //4
// char e; //4
// A objA;
//};
//struct C
//{
// char c;
// int b;
//};
//void test()
//{
//
// cout << sizeof(A) << endl;
//
// cout << sizeof(B) << endl;
//计算字节的偏移量 相对于起始位置的偏移量 借助的是地址相减
//A a;
//cout << (char*)&a.d - (char*)&a << endl;
//}
//
//int main()
//{
// test();
// return 0;
//
//}
//结构体内存对齐原因?
//提高性能，硬件

//大小端的测试
//大端；低地址存高位 高地址存高位
//小端；低地址存地位
//主要是用于网络的传输，在不同机器之间进行数据的传输的时候，就必须是保证两端的大小端是一致的
//#include
//using namespace std;
//void test()
//{
// int a = 1;
//}
//int main()
//{
// test();
// return 0;
//
//}

//日期类的
//this指针
//this指针是存在于对象当中
//#include
//using namespace std;
////class A
////{
//// int a;
////
////};
//class Date
//{
//public:
// //每一个非静态成员函数中，都是包含有一个this指针，
// //作为函数的第一个形参
// //this指向当前调用此函数的对象
// //this类型；类类型指针 const this指针的指向是不会发生变化的 就是指向是不能发生变化的，但是this指针所指向的对象的内容是可以发生变化的
// //this指针不算对象当中的成员，只是成员函数当中的一个形参
// //现在问题是要this指针干什么用？今天解决。
// //解决；由于是因为类中现在是含有不同的对象，现在我们是可以借助this指针的指向来直接获取到现在是在执行那个对象当中的内容
// void Display()
// {
// cout << _year << “-” << _month << “-” << _day << endl;
// /*A a;
// this = &a; */
// }
//
// void SetDate(int year, int month, int day)
// {
// /this->_year = year;
// this->_month = month;
// this->_day = day;/
// _year = year;
// _month = month;
// _day = day;
// //一般我们是不去加this->，但是加上是没有错的。
// }
//private:
// int _year; // 年
// int _month; // 月
// int _day; // 日
//};
//int main()
//{
// Date d1, d2;
// d1.SetDate(2018, 5, 1);
// d2.SetDate(2018, 7, 1);
// d1.Display();
// d2.Display();
// return 0;
//}
//
////this 存在于哪里？ 一般是存在于栈上，有时候是可以存储在寄存器当中。
////this指针可以为空？ 是可以为空指针 但是必须记住的是，空指针是不能进行的是空指针的解引用。

//#include
//using namespace std;
//class A
//{
//public:
// void PrintA()
// //这里是对象本身就是不存在的，所以说就是在这里进行解引用的话就不行，
// //一方面成员变量不存在，那么还有就是指针，指针是空指针，所以说是不能进行解引用的操作
// {
// cout << _a << endl;
// }
//
// void Show()
// {
// cout << “Show()” << endl;
// }
//private:
// int _a;
//};
//
//void test()
//{
// A* p = NULL;
// p->PrintA();
// p->Show(); //Show(A* const this)—>show§ 这里只是指针的传递，并不是指针的解引用。将p的值赋值给this指针
//}
//int main()
//{
// test();
// return 0;
//}

//面向对象2
//通过set函数对对象当中的内容进行修改
//#include
//using namespace std;
//class A
//{
//public:
// int _a;
// A(int a = 10)
// {
// _a = a;
// cout << “A()” << endl;
// }
//};
//class Date
//{
//public:
// //无参；默认构造；
// //编译器自动生成的构造函数也为无参的构造函数，它也是默认的构造。
// //没有显示定义无参构造，编译器会自动生成无参构造，但是一旦有显示的无参构造，那么编译器是不会再进行无参构造的生成。
// //任何一个构造函数（包括编译器自动生成的）都会自动调用自定义成员的默认构造。
// //如果没有默认构造，编译器报错
//
// //构造函数是可以进行重载。这里还是继续遵循之前函树重载的原则，无返回值，参数的个数不同就是可以构成的是构造函数的重载。
// //下边就是一个函数的构造，就是要保证的是，构造函数的命和类名是保持一致的。
// //下边是一个无参的构造函数
// Date()
// {
// cout << “Date()” << endl;
// }
// //下边是一个带参的构造
// //
// Date(int year, int month, int day)
// {
// _year = year;
// _month = month;
// _day = day;
// cout << “Date(int,int,int)” << endl;
//
// }
// //下边的也是全缺省的默认构造的一种形式 但是只能有一个默认构造。出现多个会出现问题，一般是优先使用的是全缺省的情况。
// /Date(int year = 1, int month = 1, int day = 1)
// {
// _year = year;
// _month = month;
// _day = day;
// cout << “Date(int,int,int)” << endl;
//
// }/
// Date(int year, int month, int day, int num)
// {
// _year = year;
// _month = month;
// _day = day;
// cout << “Date(int,int,int,int)” << endl;
// }
//void Display()
// {
// cout << _year << “-” << _month << “-” << _day << endl;
//
// }
//
//void SetDate(int year, int month, int day)
// {
// _year = year;
// _month = month;
// _day = day;
// //一般我们是不去加this->，但是加上是没有错的。
// }
//private:
// int _year; // 年
// int _month; // 月
// int _day; // 日
//
// //自定义类型成员
// A _a;
//};
//
//void test()
//{
// //编译器在创建对象时，自动调用构造函数
// //完成对象内容的初始化，并不是创建对象
// //调用无参构造
//
// /Date d;
// //d.SetDate(2019, 10, 2);
//
// //Date d2;
// //d.SetDate(2019, 12, 2);/
// //这里是调用的是无参的构造函数。
// Date d;
// //Date d(); 这里是声明一个函数，并不是调用的是无参构造。所以就是在调用无参构造时候，我们就是使用的是后边什么也不加。
// //Date d2(2019, 10, 2);
// //Date d3(2019, 10, 2,1000);
// //不能显示调用构造函数
// //d.Date(2020, 2, 2);
//
// //当前类的构造函数会自动调用自定义成员的默认构造，完成自定义成员的初始化。
//}
//int main()
//{
// test();
// return 0;
//}

//析构函数 资源的清理
//#include
//#include<assert.h>
//using namespace std;
//typedef int DataType;
//class SeqList
//{
//public:
// SeqList(int capacity = 10)
// {
// _pData = (DataType*)malloc(capacity * sizeof(DataType));
// assert(_pData);
//
// _size = 0;
// _capacity = capacity;
// cout<<“malloc”<<endl;
// }
// //对象销毁时候，编译器自动调用析构函数，释放资源
// ~SeqList()
// {
// if (_pData)
// {
// free(_pData); // 释放堆上的空间
// _pData = NULL; // 将指针置为空
// _capacity = 0;
// _size = 0;
// cout << “~SeqList()” << endl;
// }
// }
//
////private:
// int* _pData;
// size_t _size;
// size_t _capacity;
//};
//int* p = nullptr;
////void test1()
////{
//////动态开辟了一个空间，可以存放1000个元素
//// //空间首地址_pData保存
//// SeqList sq(1000);
//// cout << sizeof(sq) << endl;
//// p = sq._pData;
////
////}
////void tets()
////{
//// test1();
////
////}
//class Date
//{
//public:
//
// Date(int year = 1, int month = 1, int day = 1)
// {
// _year = year;
// _month = month;
// _day = day;
// cout << “Date(int,int,int)” << endl;
//
// }
// void Display()
// {
// cout << _year << “-” << _month << “-” << _day << endl;
//
// }
// //不显示定义析构，编译器会自动生成默认的析构函数。
// //析构函数自动调用自定义成员的析构函数，完成自定义成员的资源清理。
// ~Date()
// {}
//private:
// int _year; // 年
// int _month; // 月
// int _day; // 日
// //自定义成员
// SeqList _sl;
//
// //自定义成员调用自定义成员的构造，完成自定义成员的初始化。同时也会调用自定义成员的析构。
//};
//void test()
//{
// Date d(2020, 2, 3);
//}
//
//int main()
//{
// test();
// return 0;
//}

//拷贝构造
//类似于复制的操作。
//也是构造函数的一种形式，但是就是现在的拷贝构造就是用现在已经存在的对象去创建一个新的对象。
//编译器自动生成的拷贝构造；完成对象内容的拷贝，或者称为字节序拷贝，这种情况称为浅拷贝。不会拷贝资源。
//有资源的类，必须显示定义拷贝构造
#include
using namespace std;
class Date
{
public:

Date(int year = 1, int month = 1, int day = 1)
{
	_year = year;
	_month = month;
	_day = day;
	cout << "Date(int,int,int)" << endl;

}
//这里使用的是引用，如果不是引用就会引起形参的拷贝，就会引发无穷的递归，始终是不能完成传值的操作。

//下边如果不显示定义拷贝构造，编译器会自动生成拷贝构造。
/*Date(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;

}*/

private:
int _year; // 年
int _month; // 月
int _day; // 日
//自定义成员
//SeqList _sl;

//自定义成员调用自定义成员的构造，完成自定义成员的初始化。同时也会调用自定义成员的析构。

};
void test()
{
Date date(2020, 2, 3);
//调用拷贝构造，创建copy对象，内容和date完全相同。
Date copy(date);
}
int main()
{
test();
return 0;

}