【C++进阶】继承上 概念及其定义 赋值兼容转换 子类默认成员函数的详解分析

class Student
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
	void identity()
	{
		// ...
	}
	// 学习 
	void study()
	{
		// ...
	}
protected:
	string _name = "peter"; // 姓名 
	string _address; // 地址 
	string _tel; // 电话 
	int _age = 18; // 年龄 
	int _stuid; // 学号 
};
class Teacher
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
	void identity()
	{
		// ...
	}
	// 授课 
	void teaching()
	{
		//...
	}
protected:
	string _name = "张三"; // 姓名 
	int _age = 18; // 年龄 
	string _address; // 地址 
	string _tel; // 电话 
	string _title; // 职称 
};

class Person
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
	void identity()
	{
		cout << "void identity()" << _name << endl;
	}
protected:
	string _name = "张三"; // 姓名 
	string _address; // 地址 
	string _tel; // 电话 
	int _age = 18; // 年龄 
};


class Student : public Person
{
public:
	// 学习 
	void study()
	{
		// ...
	}
protected:
	int _stuid; // 学号 
};


class Teacher : public Person
{
public:
	// 授课 
	void teaching()
	{
		//...
	}
protected:
	string title; // 职称 
};
int main()
{
	Student s;
	Teacher t;
	s.identity();
	t.identity();
	return 0;
}

class Person
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
	void identity()
	{
		cout << "void identity()" << _name << endl;
	}
protected:
	string _name = "张三"; // 姓名 
	string _address; // 地址 
	string _tel; // 电话 
private:
	int _age = 18; // 年龄 
};
class Student : public Person
{
public:
	// 学习 
	void study()
	{
		// ...
		cout << _age << endl;
	}
	

protected:
	int _stuid; // 学号 
};

class Person
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
	void identity()
	{
		cout << "void identity()" << _name << endl;

		cout << _age << endl;
	}
protected:
	string _name = "张三"; // 姓名 
	string _address; // 地址 
	string _tel; // 电话 
private:
	int _age = 18; // 年龄 
};
int main()
{
	Student s;

	Teacher t;
	s.identity();
	t.identity();
	return 0;
}

namespace hxx
{
	//template<class T>
	//class vector
	//{};
	// stack和vector的关系，既符合is-a，也符合has-a 
	template<class T>
	class stack : public std::vector<T>
	{
	public:
		void push(const T& x)
		{
			// 基类是类模板时，需要指定⼀下类域， 
			// 否则编译报错:error C3861: “push_back”: 找不到标识符 
			// 因为stack<int>实例化时，也实例化vector<int>了（stack继承vector）
     // 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到 （在stack和vector<?>中均找不到则报错，）
     //因此需要指定其类域，具体可见gitee源码详解
			vector<T>::push_back(x);
			//push_back(x);
		}
		void pop()
		{
			vector<T>::pop_back();
		}
		const T& top()
		{
			return vector<T>::back();
		}
		bool empty()
		{
			return vector<T>::empty();
		}
	};
}
int main()
{
	hxx::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	return 0;
}

class Person
{
protected:
	string _name; // 姓名 
	string _sex; // 性别 
	int _age; // 年龄 
};




class Student : public Person
{
public:
	int _No; // 学号 
};


int main()
{
	Student sobj;
	// 1.派⽣类对象可以赋值给基类的指针/引⽤ 
	Person* pp = &sobj;
	Person& rp = sobj;

	
	Person pobj = sobj;

	//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错 
	//sobj = pobj;

	return 0;
}

class Person
{
protected:
    string _name = "小李子";//姓名
    int _num = 111;//身份证

};

class Student :public Person
{
public:
    void Print()
    {
        cout << _num << endl;
        cout
    }
protected:
    //在子类中便有了两个叫num的变量，父类的继承下来了，
    int _num = 999;

};

int main()
{
    Student s1;
    s1.Print();

    return 0;
}

class A
{
public:
    void fun()
    {
        cout << "func()" << endl;
    }
};
class B : public A
{
public:
    void fun(int i)
    {
        cout << "func(int i)" << i << endl;
    }
};
int main()
{
    B b;
    b.fun(10);
    return 0;
};

class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名 
};


class Student : public Person
{
public:
protected:

	int num;//学号
	string _addrss;


};

int main()
{
	Student s;

	return 0;
}

Student(const Student& s)
	:_num(s._num)
	,_addrss(s._addrss)
	,Person(s)
{
	 //深拷贝
}

	//赋值重载
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
		//父类和子类的operator构成隐藏关系
			Person::operator=(s);
			_num = s._num;
			_addrss = s._addrss;
		}

		return *this;
	}

//析构
~Student()
{
	~Person();
}

//析构 
~Student()
{
  //子类的析构和父类的析构函数构成隐藏关系
	Person:: ~Person();
}
int main()
{

	Student s1("张三",1,"南京市");

	Student s2(s1);

	Student s3("李四", 2, "成都");
	s1 = s3;
	return 0;
}

	//析构 
	~Student()
	{ 
	//子类的析构和父类的析构函数构成隐藏关系
	//规定：不需要显示调用，子类析构函数之后，会自动调用父类析构
	//这样就可以保证析构的顺序，先子后父
		//Person:: ~Person();
	}

	~Student()
	{
		Person::Person();
		delete _ptr;
	}