参考：
重点：
- 返回引用？不要返回局部变量的引用
- 对于常量对象，想修改成员变量，可以对成员对象用mutable来修饰。!!!!!!
- 重载函数，相同函数，不同参数列表，不管返回值。不要和形参默认值模棱两可，造成编译器出现歧义。
- 形参默认值，声明中指定，定义中不能指定
- 构造函数的重载，复制构造函数
- 成员函数中 加const 与不加const也构成重载：函数对当前对象的操作是只读的,怎么知道调那个？编译器会优先考虑用自由的
- 友元，使得这个函数能够操作这个类的私有成员。在这个类中进行声明
- operator >> 运算符函数:C++ 会做这两种尝试，两个都失败，会编译错误，两个都行，都模棱两可,那就不行,只有一个可以，那就可以。
// //不会调构造
// Person* q = static_cast<Person*>(malloc(sizeof(Person)));
// //不会调析构
// free(q);
// //函数声明，函数名e,返回类型 是Person， 末尾的空括号，很容易引起歧义!!!!
// //Person e();
- // 有const修饰的对象只能调用const修饰的成员函数
问题：
- 对象还是指针？？？？？new一个对象，有调用构造函数就是创建对象!!!! Person* p = new Person;
正文：
//达内C++教程\03_标准C++编程_陈宗权_7day\标准C++编程_day03PM_构造器
#include<iostream>
#include<string>
using namespace std;
//不属于任何类的函数是全局函数，
//成员函数，直接访问类中的数据，不需要它传参数，与多个函数共享参数
//返回引用？不要返回局部变量的引用，请举例子！！！！！
//重载函数，相同函数，不同参数列表，不管返回值。不要和形参默认值模棱两可，造成编译器出现歧义。
//构造函数有重载
//析构函数没有重载！！！！！总是无参。你可以自己调多次析构函数！！！人为调用不会影响系统调用析构函数。
//对于常量对象，想修改成员变量，可以对成员对象用mutable来修饰。!!!!!!
class Person {
string name;
bool gender;
int age;
Person *lover;
public:
//没有定义构造函数,系统就会产生无参构造函数，什么都不做
//只要定义了构造函数，编译器不会产生无参的构造函数
//形参默认值，声明中指定，定义中不能指定
Person(const char* n="wuming",bool g = true);
//析构函数就是无参的，什么都不做
~Person();
//形参是类类型，必须加const &
//构造函数的重载，复制构造函数
Person(const Person& p):name(p.name), gender(p.gender){ std::cout <<"Person(Person)" << std::endl; }
void growup(int years);
void show();
//成员函数中 加const 与不加const也构成重载：函数对当前对象的操作是只读的,怎么知道调那个？编译器会优先考虑用自由的
void show() const;
void marry(Person& oth);
friend istream& operator >> (istream& in, Person& p);
friend ostream& operator<<(ostream& out, const Person& p);
};
Person::Person(const char* name, bool gender):name("xxxx"),gender(1)//成员变量名(初始值)
{
//this是个常量，不允许指向别处
this->name = name;
(*this).gender = gender;
age = 0;
lover = NULL;
std::cout <<"调用构造" <<this << std::endl;
}
Person::~Person()
{
std::cout <<"调用析构"<<name;
std::cout << this<< std::endl;
}
void Person::growup(int years)
{
age += years;
}
void Person::show() {
std::cout << "自由的" << std::endl;
std::cout << "大家好，我是" << name << (gender ? ",帅哥" : ",美女") << ", 今年" << age << "，";
if (lover == NULL)
cout<<"目前单身贵族。"<< std::endl;
else
cout << "爱人是：" << lover->name << std::endl;
}
void Person::show() const {
std::cout << "不自由的" << std::endl;
std::cout << "大家好，我是" << name << (gender ? ",帅哥" : ",美女") << ", 今年" << age << "，";
if (lover == NULL)
cout << "目前单身贵族。" << std::endl;
else
cout << "爱人是：" << lover->name << std::endl;
}
void Person::marry(Person& oth)
{
if (gender == oth.gender) {
std::cout << "不符合条件 "<< std::endl;
return;
}
lover = &oth;
oth.lover = this;
std::cout <<name<<"和" <<oth.name<<"喜结良缘。"<< std::endl;
}
Person eeee()
{
string name;
bool gender;
cout << "请输入姓名和性别";
cin >> name >> gender;
Person input(name.c_str(), gender);
input.growup(12);
return input;
}
// 进入会创建对象，离开会释放，引用的化，就不会调构造，不会掉析构
void compare(Person a, Person) {
}
//TEST1
//int main()
//{
// //对象还是指针？？？？？new一个对象，有调用构造函数就是创建对象。堆还是栈？？？
// Person* p = new Person;
//
// //不会调构造
// Person* q = static_cast<Person*>(malloc(sizeof(Person)));
// //不会调析构
// free(q);
//
// q = new Person[4];
// for (int i = 0; i < 4; i++) {
// q[i].show();
// }
// delete[] q;
//
// Person a("furong", false);
// Person b("yangqiang",true);
// a.growup(18);
// b.growup(20);
// a.show();
// b.show();
//
// Person c;
// c.growup(10);
// c.show();
//
// //函数声明，函数名e,返回类型 是Person， 末尾的空括号，很容易引起歧义!!!!
// //Person e();
// //e.growup();
//
// eeee().show();
//
// Person d("ergou");
// d.growup(4);
// d.show();
// b.marry(a);
// std::cout << "结婚: "<< std::endl;
// a.show();
// b.show();
//
// delete p;
//
// //
// const Person fff;
// fff.show();
//
// std::cout <<"............................................." << std::endl;
//
// compare(a,b);
// std::cout << "............................................." << std::endl;
//
// system("pause");
//}
////TEST2
//Person func(Person q )
//{
// return q;
//}
//
//int main()
//{
// Person a;
// std::cout <<"..................................." << std::endl;
// //形参：F q(a)
// //返回值：
// func(a);
// std::cout << "..................................." << std::endl;
// // 有const修饰的对象只能调用const修饰的成员函数
// const Person b;
// //b.growup();
// b.show();
// system("pause");
//}
//TEST3 IO
//void operator>>(istream& in, int& n){}
//友元，使得这个函数能够操作这个类的私有成员。在这个类中进行声明
istream& operator>>(istream& in, Person& p) {
//将相关东西写入p的成员变量中
char c;
in >> p.name >> c >>p.age;
return in;
}
//引用的目的是不在复制一份
ostream& operator<<(ostream& out, const Person& p) {
out << p.name <<", "<< p.age;
return out;
}
int main()
{
int a;
//cin >> a;
//cin.operator>>(a);//成员函数
//operator>>(cin,a);// C++ 会做这两种尝试，两个都失败，会编译错误，两个都行，都模棱两可,那就不行,只有一个可以，那就可以。，operator >> 运算符函数
Person p,q;
//operator>>(cin, p);
cin >> p >> q;
operator<<(cout,p);
system("pause");
}
网友评论