[陈宗权C++]C++第3天AMPM--构造器，析构，IO

作者: Optimization | 来源:发表于2020-01-29 17:22 被阅读0次

[陈宗权C++]C++第3天AMPM--构造器，析构，IO
windows逆向3
简介python中的析构函数与构造函数
Effective C++笔记
第7条避免使用终结方法
c++构造函数，析构函数，调用顺序
[C++之旅] 13 析构函数
Effective C++ 学习备忘录二
c++学习笔记2（GeekBand）
Effective C++_读书笔记_102

参考：

重点：

返回引用？不要返回局部变量的引用
对于常量对象，想修改成员变量，可以对成员对象用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");
}