数据结构复习笔记：C++程序设计（二）

1、动态存储分配：
（1）new操作符：进行动态存储分配，返回一个指向所分配空间的指针。

#include <iostream>
using namespace std;

int main(int argc, char* argv[]) {
     int *p1 = new int(8);
     cout << p1 << endl; // 输出指针p的地址
     cout << *p1 << endl; // 8
     delete p1;

     int *p2;
     p2 = new int(2017);
     delete p2;

     return 0;
}

（2）一维数组动态存储分配：（对比静态数组和动态数组）

#include <iostream>
using namespace std;

int main(int argc, char* argv[]) {
    float f1[2] = {5, 8}; // 静态数组，在栈内存，性能高，但是大小限定
    cout << *f1 << endl; // 5
    cout << f1[0] << endl; // 5
    cout << f1[2] << endl; // 越界, 虽然可能正常运行，但是数据无效，并且可能导致冲突崩溃

    float *f2 = new float[2]; // 动态数组，在堆内存，可以不限定数组大小，2只是初始化的大小空间
    f2[0] = 8, f2[1] = 10;
    f2[2] = 20;
    cout << *f2 << endl; // 8
    cout << f2[0] << endl; // 8
    cout << f2[2] << endl; // 20，不越界正常,但是不是存在预先指定的内存地址中，存在无效的可能，不要如此用，可以扩大内存将原有数据拷贝过去
    delete[] f2;

    return 0;
}

（3）二维数组动态存储分配：

#include <iostream>
using namespace std;

int main(int argc, char* argv[]) {
    int num1[2][3] = {{0, 1, 3} , {2, 5, 8}}; // 静态二维数组
    cout << num1[1][1] << endl; // 5

    char c2[][3] = {'a', 'b', 'c', 'd', 'e', 'f'}; // 静态二维数组（不设置一维数目，根据二位数量和赋值数量自动计算出6/3=2）
    cout << c2[1][1] << endl; // e

    int **num2 = new int*[3]; // 动态二维数组，生产环境中这里的3通常是动态传入，表示指针数组num2包含3个元素
    num2[2] = new int[5];
    num2[2][4] = 8;
    cout << num2[2][4] << endl; // 8
    delete[] num2[2];
    delete[] num2;

    return 0;
}

2、类的使用（继承、多态、虚函数、友元函数）：

#include <iostream>
#include <string>
using namespace std;

class Person {
    protected:
        string name; // 或 char *name;
        unsigned int age;
    public:
        Person() {} // 默认构造函数
        Person(char *name, unsigned int age);// 构造函数，将实现放到外部
        ~Person() {} // 析构函数
        virtual void saySth() const;
        virtual void work() const = 0; //  = 0标记将其定义为纯虚函数，抽象方法，父类不能实现，由派生类实现

}; // 注意c++这里要加上分号

Person::Person(char *name, unsigned int age) {
    this->name = name;
    this->age = age;
}

void Person::saySth() const {
    cout << "Hello, person!" << endl;
}


class Student : public Person { // 继承的权限关键词public必需加上，否则默认是private，无法利用类型转换，实现多态
    private:
        float score;
    public:
        Student(); 
        Student(char *name, unsigned int age, float score);
        ~Student() {}
        int operator-(const Student& stu) const; // 重载“-”运算符计算两个学生的成绩差，const关键词不允许修改类的成员
        friend float addOne(float num); // 友元函数，类外定义，不为当前类独有，但是可以访问类的私有成员
        virtual void saySth() const;
        virtual void work() const;
        static void sayIdentity(); // 静态方法
        void sayHi() const { // 实例方法, 将实现放到内部
            cout << name << "->" << age << ", " << score << ": Hi!" << endl;
        }
        void setScore(float score) {
            this->score = score;
        }

};

Student::Student() {
    this->name = "Willson";
    this->age = 18;
    this->score = 100;
}

Student::Student(char* name, unsigned int age, float score) : Person(name, age) { // Person后面的name和age是实参，由Student构造方法的形参接收的实参传入，Person前面的冒号表示调用父类的某个构造函数
    this->score = score;
}

void Student::sayIdentity() { // 实现部分不需要写static
    cout << "student" << endl;
}

void Student::saySth() const {
    cout << "Hello, student!" << endl;
}

void Student::work() const {
    cout << "working" << endl;
}

int Student::operator-(const Student& stu) const {
    return this->score - stu.score;
}

float addOne(float num) { // 友元函数，不要写成Student::addOne
    return num + 1;
}

int main(int argc, char* argv[]) {
    Student *stu1 = new Student("Tafeng", 10, 99.5); // new方式定义的，需要delete释放内存
    stu1->sayHi(); // Tafeng->10, 98.5: Hi!
    delete stu1;

    Person *p = new Student(); // 虚函数，多态
    p->saySth(); // Hello, student!
    delete p;

    Student stu2; // 直接定义的，不需要手动释放内存
    stu2.sayHi(); // Willson->18, 100: Hi!

    Student stu3;
    stu3.setScore(75);

    int scoreDiff = stu2 - stu3; // 不能是stu1 - stu2，因为重载的参数Student& stu不是指针
    cout << scoreDiff << endl; // 100 - 75 = 25

    int newScore = addOne(75);
    cout << newScore << endl; // 76

    Student::sayIdentity(); // student

    return 0;
}

3、设计测试数据：
（1）黑盒法：考虑程序的实际功能，而不是实际的代码。常用方法：I/O分类法，因果图。
（2）白盒法：通过检查程序代码来设计测试数据，使测试数据的执行结果能够很好的覆盖程序的语句及执行路径。要求每一个测试集对程序中的每一条语句至少执行一次（语句覆盖）。