//基类classPerson {
public:
//被final修饰，该虚函数不能再被重写virtualvoidBuyTicket() final    { 
cout<<"Person-买票-全价"<<endl; 
    }
};
//派生类classStudent : publicPerson {
public:
//派生类的虚函数重写了父类的虚函数virtualvoidBuyTicket() { cout<<"Student-买票-半价"<<endl; }
};

//基类使用 final 修饰classAfinal{};
//派生类无法进行继承基类classB : publicA{};

//基类classPerson {
public:
//基类的虚函数virtualvoidBuyTicket() { cout<<"Person-买票-全价"<<endl; }
};
//派生类classStudent : publicPerson {
public:
//派生类完成了虚函数的重写，编译通过virtualvoidBuyTicket()override    { 
cout<<"Student-买票-半价"<<endl; 
    }
};
//派生类classSoldier : publicPerson{
public:
//派生类没有完成虚函数的重写，编译报错virtualvoidBuyTicket(intn)override    { 
cout<<"Soldier-优先-买票"<<endl;
    }
};

namespacefy{
classstring    {
public:
//构造函数string(constchar*str="")
        {
_size=strlen(str);//字符串大小_capacity=_size;//构造时，容量大小默认与字符串大小相同_str=newchar[_capacity+1];//为字符串开辟空间（多开一个用于存放'\0'）strcpy(_str, str);//将C字符串拷贝到已开好的空间        }   
//拷贝构造 -- 现代写法string(conststring&s)
            :_str(nullptr)
            , _size(0)
            ,_capacity(0)
        {
cout<<"string(const string& s) -- 深拷贝"<<endl;
stringtmp(s._str);//复用构造函数，构造 tmp对象swap(tmp);//交换        }
//赋值重载 -- 现代写法1string&operator=(conststring&s)
        {
cout<<"string& operator=(const string& s) -- 深拷贝"<<endl;
if (this==&s)//检查自我赋值            {
return*this;
            }
stringtmp(s);//复用拷贝构造函数，用s拷贝构造出对象tmpswap(tmp);
return*this;//返回左值，目的是为了支持连续赋值        }
// 移动构造string(string&&s)
            :_str(nullptr)
            , _size(0)
            , _capacity(0)
        {
cout<<"string(string&& s) -- 移动语义"<<endl;//更明显观察是否调用了该函数swap(s);//与右值的资源进行直接交换，不进行深拷贝        }
// 移动赋值string&operator=(string&&s)
        {
cout<<"string& operator=(string&& s) -- 移动语义"<<endl;//使更明显观察是否调用了该函数swap(s);//与右值的资源进行直接交换，不进行深拷贝return*this;//支持连续赋值        }
//析构函数~string()
        {
delete[] _str; //释放_str指向的空间_str=nullptr;
_size=_capacity=0;
        }
//交换两个字符串voidswap(string&s)
        {
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
        }
private:
char*_str;
size_t_size;
size_t_capacity;
    };
}

classPerson{
public:
//构造函数Person(constchar*name="", intage=0)
        :_name(name)
        , _age(age)
    {}
private:
fy::string_name;
int_age;
};
intmain()
{
Persons1;
Persons2=s1;
Persons3=std::move(s1);
Persons4;
s4=std::move(s2);
return0;
}

classPerson{
public:
//构造函数Person(constchar*name="", intage=0)
        :_name(name)
        , _age(age)
    {}
拷贝构造//Person(const Person& p)// :_name(p._name)// ,_age(p._age)//{}赋值重载//Person& operator=(const Person& p)//{//  if(this != &p)//  {//      _name = p._name;//      _age = p._age;//  }//  return *this;//}//析构函数~Person()
    {}
private:
fy::string_name;
int_age;
};
intmain()
{
Persons1;
Persons2=s1;
Persons3=std::move(s1);
Persons4;
s4=std::move(s2);
return0;
}

classPerson{
public:
//...private:
//非静态成员变量，可以在成员声明时给缺省值string_name="张三"; //缺省值int_age=22;         //缺省值staticint_n; //静态成员变量不能给缺省值};

classPerson{
public:
//构造函数Person(constchar*name="", intage=0)
        :_name(name)
        , _age(age)
    {}
//拷贝构造Person(constPerson&p)
     :_name(p._name)
     ,_age(p._age)
    {}
//移动构造Person(Person&&p) =default;
private:
fy::string_name;
int_age;
};
intmain()
{
Persons1;
Persons2=s1;
Persons3=std::move(s1);
return0;
}

classA{
public:
A()
    {}
private:
//强制不允许生成A(constA&) =delete;
A&operator=(constA&) =delete;
};
intmain()
{
Aa1;
Aa2(a1);
return0;
}