C++ 再识类和对象

目录

• 类的6个默认成员函数
• 构造函数

• 1.概念
• 2.特性
• 隐式构造函数

• 无参和全缺省的函数均为默认构造函数

• 补充

• 1.概念

• c++编译器在对象生命周期结束时自动调用析构函数

• 1.概念

• 若未显式定义，系统会生成默认的拷贝构造函数
• 浅拷贝的注意事项

class Date
{
public:
	void SetDate(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.SetDate();
	d1.Print();
	return 0;
}

class Date
{
public:
	Date()//无参的构造函数
	{
		_year = 0;
		_month = 1;
		_day = 1;
	}
	//带参的构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//调用无参的构造函数
	Date d2(0, 1, 1);//调用带参的构造函数
	Date d3();//无参，返回值为Date的函数声明
	return 0;
}

class C
{
public:
	C()
	{
		cout << "C()" << endl;
	}
private:
	int _c;
};
class Date
{
public:
	//若用户显式定义了构造函数，那么编译器将不再生成
	/*Date()
	{
		_year = 0;
		_month = 1;
		_day = 1;
	}
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}*/
private:
	//内置类型
	int _year;
	int _month;
	int _day;
	//自定义类型
	C c1;
};
int main()
{
	Date d1;//调用无参的构造函数
	return 0;
}

class Stack//栈
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
struct MyQueue//用两个栈实现队列
{
	Stack s1;
	Stack s2;
};

class Date
{
public:
	Date()
	{
		_year = 0;
		_month = 1;
		_day = 1;
	}
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//错误，编译器无法识别要调用哪一个构造函数
	return 0;
}

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		year = year;
		month = month;
		day = day;
	}
	void Print()
	{
		cout << year << "/" << month << "/" << day << endl;
	}
private:
	int year;
	int month;
	int day;
};
int main()
{
	Date d1;
	d1.Print();
	return 0;
}

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	//注意，此处仅为缺省值，仍为变量声明，而非初始化（定义）
	int _year = 0;
	int _month = 1;
	int _day = 1;
};

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_a);
		_a = NULL;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
struct MyQueue
{
	Stack s1;
	Stack s2;
};
int main()
{
    //我们无需自己对mq进行初始化和清理空间
    //编译会自动调用构造函数和析构函数
	MyQueue mq;
	return 0;
}

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	return 0;//编译器在执行这句代码的同时会调用类中的析构函数
}

class Date
{
public:
	Date()
	{
		_year = 0;
		_month = 1;
		_day = 1;
	}
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(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;
}

class A
{
public:
	A()
	{
		_a = 0;
	}
	A(const A& a)
	{
		cout << "A(const A& a)" << endl;
	}
private:
	int _a;
};
class Date
{
public:
	Date()
	{
		_year = 0;
		_month = 1;
		_day = 1;
	}
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//调用默认的拷贝构造函数
	/*Date(Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}*/
private:
	int _year;
	int _month;
	int _day;
	A aa;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_a);
		_a = NULL;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack s1(8);
	Stack s2(s1);
	return 0;
}