C++类和动态内存分配练习

1.给这个类提供实现，并编写程序使用所有成员函数

  char name[20];
  char* hobby;
  double weight;
public:
  Cow();
  Cow(const char* nm,const char* ho,double wt);
  Cow(const Cow& c);
  ~Cow();
  Cow& operator= (const Cow& c);
  void showcow() const;
}; 

源代码文件如下:

#include"cow.h"
#include
#include
Cow::Cow()
{
    strcpy(name,"Jeff");
    hobby = new char[3];
    strcpy(hobby,"No");
    weight = 100;
}

Cow::Cow(const char* nm,const char* ho,double wt)
{
    strcpy(name,nm);
    hobby =  new char[strlen(ho),+1];
    strcpy(hobby,ho);
    weight = wt;
}

Cow::Cow(const Cow& c)
{
    strcpy(name,c.name);
    hobby = new char[strlen(c.hobby)+1];
    strcpy(hobby,c.hobby);
    weight = c.weight;
}

Cow::~Cow()
{
    std::cout<

程序解析：

1. hobby是字符串指针，你不能直接用strcpy(hobby,"xxx")或者hobby = ho等，因为你用strcpy的话是把“xxx”复制到hobby所指的内存地址，此时hobby没有指向什么地方。赋值运算符=ho也是同样的道理。如果你hobby = &("xx") 就是将非const指向const了。
   所以最好就是new 开辟内存空间。
2. 析构函数要delete []
3. 重载赋值运算符要返回this指针指向的对象

#include"cow.h" 
#include
int main()
{
    using std::cout;
    using std::endl;
    Cow c1;
    Cow c2("Jack","Doing sports",120.0);
    Cow c3(c2);
    Cow c4;
    c4 = c3;
    cout<<"C1:\n";
    c1.showcow();
    cout<<"C2:\n";
    c2.showcow();
    cout<<"C3:\n";
    c3.showcow();
    cout<<"C4:\n";
    c4.showcow();
    return 0;
}

结果：

image.png

题目

image.png

类声明文件
#ifndef PORT_H_
#define PORT_H_
#include
using namespace std;

class Port
{
    private:
        char* brand;
        char style[20];
        int bottles;
    public:
        Port(const char* br ="none",const char* st ="none",int b=0);
        Port(const Port& p);
        virtual ~Port() {delete [] brand;}
        Port& operator=(const Port& p);
        Port& operator+=(int b);
        Port& operator-=(int b);
        int BottleCount () const {return bottles;}
        virtual void Show() const;
        friend ostream& operator<<(ostream& os, const Port& p);
 }; 
 
 class VPort : public Port
 {
    private:
        char* nickname;
        int year;
    public:
        VPort();
        VPort(const char* br,const char* st,int b,const char* nn,int y);
        VPort(const VPort& vp);
        ~VPort(){delete [] nickname;}
        VPort& operator=(const VPort& vp);
        void Show() const;
        friend ostream& operator<<(ostream& os,const VPort& vp);
        
 };
 
 #endif

程序解析：

1. 为何没有将运算符重载声明为虚函数呢：
   因为参数不一样，特征不同，没有必要声明为虚函数
2. operator<<为友元因为调用对象是ostream类

源代码文件
#include"port.h"
#include
Port::Port(const char* br, const char* st, int b)
{
    brand = new char[strlen(br)+1];
    strcpy(brand,br);
    strcpy(style,st);
    bottles = b;
}

Port::Port(const Port& p)
{
    brand = new char[strlen(p.brand)+1];
    strcpy(brand,p.brand);
    strcpy(style,p.style);
    bottles = p.bottles;
}


Port& Port::operator=(const Port& p)
{
    if(this == &p)
        return *this;
    delete [] brand;
    brand = new char[strlen(p.brand)+1];
    strcpy(brand,p.brand);
    memset(style,'\0',20);
    strcpy(style,p.style);
    bottles = p.bottles;
    return *this;
}

Port& Port::operator+=(int b)
{
    bottles += b;
    return *this;
}

Port& Port::operator-=(int b)
{
    bottles -= b;
    return *this;
}

void Port::Show() const
{
    cout<<"Brand: "<

程序解析:

1. 主要讲讲派生类成员函数调用基类成员函数：
   比如运算符重载=函数： 调用基类重载=运算符 Port::operator=(vp),
   首先，调用对象是this，所以this指向返回的对象引用。
   其次，实参为vp，是基类引用，重载函数根据这个特征来使用不同的函数。
2. 重载<<运算符，因为是友元函数，所以也是多态函数，利用强制类型转换（类型要相同比如const转换为const）可以使派生类引用变为基类引用，从而使用基类友元重载运算符<<.