windows实验3——c++

1、getline的使用

#include <iostream>
#include<string>

using namespace std;

int main()
{
    for(int i=0;i<2;i++){
        string city,state;
        getline(cin,city,',');
        getline(cin,state);
        cout<<"City:"<<city<<"  State:"<<state<<endl;
    }
    return 0;
}

结果：

Beijing,China
City:Beijing  State:China
San Francisco,the Unite States
City:San Francisco  State:the Unite States

2、类的继承

1、类型兼容规则实例

#include <iostream>

using namespace std;

class Base1 {
public:
    void display() const {cout<<"Base1::display()"<<endl;}
};

class Base2:public Base1 {
public:
    void display() const {cout<<"Base2::display()"<<endl;}
};

class Derived:public Base2 {
public:
    void display() const {cout<<"Derived::display()"<<endl;}
};

void fun(Base1 *ptr){
    ptr->display();
}

int main()
{
    Base1 base1;
    Base2 base2;
    Derived derived;

    fun(&base1);
    fun(&base2);
    fun(&derived);

    return 0;
}

结果：

Base1::display()

Base1::display()

Base1::display()

用基类的指针指向子类的对象，然后调用成员函数，只能够调用基类的成员函数而不是子类的成员函数。

2、派生类构造函数

#include <iostream>

using namespace std;

class Base1 {
public:
    Base1(int i){cout<<"Constructing Base1 "<<i<<endl;}
    ~Base1(){cout<<"Destructing Base1"<<endl;}
};
class Base2{
public:
    Base2(int i){cout<<"Constructing Base2 "<<i<<endl;}
    ~Base2(){cout<<"Destructing Base2"<<endl;}
};
class Base3{
public:
    Base3(){cout<<"Constructing Base3 *"<<endl;}
    ~Base3(){cout<<"Destructing Base3"<<endl;}
};

class Derived:public Base2,public Base1,public Base3 {
public:
    Derived(int a,int b,int c,int d):Base1(a),member2(d),member1(c),Base2(b){}
private:
    Base1 member1;
    Base2 member2;
    Base3 member3;
};

int main()
{
    Derived obj(1,2,3,4);
    return 0;
}

结果：

Constructing Base2 2

Constructing Base1 1

Constructing Base3 *

Constructing Base1 3

Constructing Base2 4

Constructing Base3 *

Destructing Base3

Destructing Base2

Destructing Base1

Destructing Base3

Destructing Base1

Destructing Base2

先调用基类的构造函数，再调用内嵌对象的构造函数。

基类构造函数的调用顺序是按照派生类定义时的顺序，而内嵌对象的构造函数的调用顺序是按照成员在类中声明的顺序。

在执行析构函数是，执行顺序与构造函数完全相反。