C++特性

1.如何定义一个类

class class1
{
public:
    char name[64];
    int age;
};

2.如何定义一个对象（对象就是类的实例化，就是怎么用这个类）

直接定义：
class1 my1;

在堆里定义：
class1* my2 = new class1;

删除对象（只能删除在堆里定义的对象，为了释放在堆里的内存）：
delete my2;

3.反问类里的成员

class1 my1;
class1* my2 = new class1;

my1.age = 18;
my2->age = 20;

cout << my1.age << endl; // 18
cout << my2->age << endl; // 20

 4.如何定义类里的函数

#include <iostream>

using namespace std;

class class1
{
public:
    char name[64];
    int age;
    void test1(){ // 在类里面直接写好函数，方法的大括号后面不用加分号
      cout << 123456 << endl;
    }
    void test2(); // 让别人在外面自定义这个函数，没有大括号，要加分号
};

void class1::test2(){
    cout << 234567 << endl;
}

int main()
{
    class1 my1;
    class1* my2 = new class1;

    my1.test1(); // 123456
    my2->test1(); // 123456

    my1.test2();  // 234567
    my2->test2(); // 234567

    return 0;
}

5.类里的函数的重载性（就是同一个类里，可以定义多个函数名相同但参数不同的函数）

#include <iostream>

using namespace std;

class class1{
public:
    void fun1();
    void fun1(int a);
};

void class1::fun1(){
    cout << 123 << endl;
}
void class1::fun1(int a){
    cout << a << endl;
}


int main()
{
    class1 my1;
    my1.fun1(); // 123
    my1.fun1(234); // 234
    return 0;
}

6.类的修饰符

public: 表示函数和变量是公开的，任何人都可以访问。

private: 表示函数和变量只能在自己的类里面使用
#include <iostream>
using namespace std;
class class1{
public:
    char ch[10];
    int a = 10;
    void fun1();
private:
    int b = 20;
};
void class1::fun1(){
    cout << b << endl;
}
int main()
{
    class1 my1;
    cout << my1.a << endl; // 10
    //cout << my1.b << endl; // 报错
    my1.fun1(); // 20 通过这个函数，让这个函数来访问自己同一个类里的变量
    return 0;
}

protected: 表示函数和变量只能在自己的类里面使用，并且还可以被派生类来访问

 7.构造函数和析构函数

构造函数是类被定义(初始化)的时候触发  // 函数名要和类名一样，不需要返回类型，可以被重载(有形参，但是声明的时候需要 class1 my1(形参) 或者  class1* my2 = new class1(形参) )
析构函数是类被销毁(被删除或者生命周期结束)的时候触发 // 函数名要和类名一样并且前面要加 ~ ，不需要返回类型，不能被重载
#include <iostream>
using namespace std;
class class1{
public:
    int a = 10;
    class1(); // 构造函数
    ~class1(); // 析构函数
};
class1::class1(){
    cout << 111 << endl;
}
class1::~class1(){
  cout << 222 << endl;
}
int main()
{
    class1 my1; // 111
    class1* my2 = new class1; // 111
    delete my2; // 222
    return 0; // 222
}

 8.类的继承

#include <iostream>

using namespace std;

class class1{
public:
    int a = 10;
private:
    int b = 20;
};

class class2:public class1{
public:
    int c = 30;
};

int main()
{
    class2 my1;
    cout << my1.c << endl; // 30
    cout << my1.a << endl; // 10
    //cout << my1.b << endl; // 这个会报错私有的(private)不能被继承,protected也报错
    return 0; // 222
}

 9.虚函数和存虚函数

虚函数：有实际定义的，允许派生类对他进行覆盖式的替换，用virtual来修饰，用在类的继承上，如果子类有个函数名和父类一样可以将父类的函数替换
纯虚函数：没有实际定义的虚函数就是纯虚函数

#include <iostream>

using namespace std;

class parent{
public:
    int a = 10;
    virtual void test(){ // 虚函数  好像加不加virtual,子类上名字一样的函数都能替换掉当前的函数,可能编译时结构不一样吧
        cout << 111 << endl;
    }
    virtual void test2(){} // 存虚函数，里面没有任何代码
};

class children:public parent{
public:
    int b = 20;
    void test(){
        cout << 222 << endl;
    }
};

int main()
{
    parent my;
    my.test(); // 111
    children my2;
    my2.test(); // 222
    my.test(); // 111

    return 0;
}

 

----------------------------------- 07/15

声明函数时，函数的形参给默认值时必须从后往前