C++学习记录（二）引用，动态开辟空间，类，get与set方法，构造函数

这是第二天学习的代码。

#include <iostream>

using namespace std;

// 引用
int add(int& a, int& b)
{
    return a+b;
}
void swap(int& a, int& b)
{
    int c = a;
    a = b;
    b = c;
}

// 动态开辟空间
void test1()                        // C中动态开辟空间
{
    int* pa = (int*)malloc(sizeof(int));
    cout << *pa << endl;            // 随机值

    int* pb = (int*)calloc(1, sizeof(int));
    cout << *pb << endl;            // 0

    free(pa);
    free(pb);
    pa = NULL;
    pb = NULL;
}
void test2()                         // C++中动态开辟空间
{
    int* pa = new int;
    cout << *pa << endl;            // 对应malloc

    int* pb = new int(100);
    cout << *pb << endl;

    int* pc = new int[4];
    pc[0] = 200;
    pc[1] = 300;
    cout << *pc << endl;
    cout << *(pc+1) << endl;

    delete pa;
    delete pb;
    delete []pc;
}

// class对象，struct数据
class Person
{
private:
    string name;
    int age;
    char sex;

public:
    Person() = default;
    Person(string _name, int _age, char _sex)
    {
        name = _name;
        age = _age;
        sex = _sex;
    }

    void work() { cout << " I'm working !" << endl; }
    void eating() { cout << " I'm eating !" << endl;}
    void setName(const string& _name) { name = _name; }
    string gatName() { return name; }
    void setAge(int _age) { age = _age; }
    void showInfo()
    {
        cout << "Person Infomation: " << name << ", Age: " << age << ", Sex: " << sex << "." << endl;
    }

};

//
enum Sex
{
    female,
    male
};

//#pragma pack(1)             // 取消字节对齐，即按1对齐
class Student               // 第一个字母大写
{
private:
    string name;            // 32个字节
    int age;                // 4个字节
    Sex sex;                // 4个字节
    char ff;

public:
    //Student() {};           // 默认构造函数，无参空构造

    // 默认有参构造，不能与默认构造函数重复出现，编译器提供优化后的

    Student(string name = "", int age = 0)
    {
        this->name = name;
        this->age = age;
        cout << "I'm " << this->name << ", age " << this->age << endl;
    }

    ~Student() {};

    void writeCode() { cout << "I'm writing code !" << endl; }
    void eat_launch() { cout << "I'm eating launch !" << endl;}

    void setName(const string& name) { this->name = name; }
    string getName() { return this->name; }

    void setAge(int age) { this->age = age; }
    int getAge() { return this->age; }

    void setSex(Sex sex) { this->sex = sex; }
    Sex getSex() { return this->sex; }

};
//#pragma pack()

// 设计一个平面类，属性：长，宽，行为：求面积
class Plane
{
private:
    int length;
    int width;

public:
    int area() const { return this->length * this->width; } // 主要常函数的写法
    void setValue(int length = 1, int width = 1)            // 函数重载时不能设置默认值
    {
        this->length = length;
        this->width = width;
    }
};

bool compaired(const Plane& p1, const Plane& p2)            // 常对象，只能访问不能修改,只能调用常函数，
{
    return p1.area() > p2.area() ? true: false;
}

//

int main()
{
    // -1- 引用(主要用在函数传参)
    // 从编译器角度，就是指针；从语法角度，是const修饰的指针，调用时不可修改。
    /*
    int a = 100;
    int* p = &a;                    // 指针p，变量a的地址
    cout << *p << endl;
    *p = 200;
    cout << *p << endl;
    cout << a << endl;

    //int* const b = &a;
    int& b = a;                     // 引用必须初始化
    int data1 = 300;
    int data2 = 400;
    swap(data1,data2);
    cout << "data1 = " << data1 << endl;
    cout << "data2 = " << data2 << endl;
    */

    // -2- 动态开辟空间
    // C++中用new开辟，delete释放
    /*
    test1();
    test2();
    */

    // 类与对象抽象与封装
    /*
    Person p1;
    p1.work();

    Person* p2 = new Person;

    Person p3("zhangsan",18,'M');
    p3.showInfo();
    p3.setAge(20);
    p3.setName("Lisi");
    p3.showInfo();
    */

    // -3- 类对象与get,set方法
    /*
    Student stu1;
    cout << sizeof (stu1) << endl;                  // 48,取消字节对齐后变为41
    //cout << sizeof (Student) << endl;               // 48,取消字节对齐后变为41
    // 1 求出类中所占内存最大的，以这个内存空间大小为基准，进行内存字节对齐。
    // 2 结构体与数值是连续存储的，也要求每个元素中最大空间的那一个，为基准。

    Student zhangsan;
    zhangsan.setName("zhangsan");
    zhangsan.setAge(18);
    zhangsan.setSex(Sex::male);
    cout << zhangsan.getName() << "\t" << zhangsan.getAge() << "\t" <<endl;
    switch ( zhangsan.getSex() ){
        case Sex::male:
            cout << "Boy." << endl;
            break;
        case Sex::female:
            cout << "girl." << endl;
            break;
    }
    */

    // -4- 类设计与常对象
    /*
    Plane p1;
    p1.setValue(2,3);
    cout << p1.area() << endl;

    Plane p2;
    p2.setValue(3,4);
    cout << p2.area() << endl;

    if (compaired(p1,p2))
    {
        cout << " P1 is the larger one. " << endl;
    }
    else
    {
        cout << " P2 is the larger one. " << endl;
    }
    */

    // -5- 构造函数
    // 构造函数：初始化类中的属性；
    // 当类对象在内存中被定义时，会自动调用对应的构造函数;
    // 默认构造函数会根据调用方式不同而不同，在栈区定义无参对象(不带括号)，会调用无参构造函数，
    //                                在堆区定义无参对象(指针)，会调用有参且为默认值的构造函数。
    //Student stu3;                       // 隐式构造，会调用无参构造，不能加括号
    //Student* stu4 = new Student;        // 这是在堆区的隐式调用，在调用无参构造时，可以加括号也可不加，前提手写无参构造函数

    //Student stu5("zhangsan",18);          // 显示调用
    Student* stu6 = new Student();          // 在堆区的显示调用


    cout << "Hello World!" << endl;
    return 0;
}