C++入门小知识点

1、基本面向对象

People *p=new People();
p->sayHello();

//C++没有垃圾回收机制，需要用delete关键字
delete p;

//new ----->delete

//C语言的
//malloc(size_t)
//free(void *)

2、继承

class Man :public People
{
public:
};  

3、构造和析构

析构的意思大概是在对象在被销毁之前，手动释放一些空间等

class People{
public:
    Object(){
        printf("Create object");
    }
    ~Object(){
        printf("Delete object");
    }
}

void creatObj(){
    {
        People p;
    }
    printf("run");
    //****************
    //以上的输出为 create ,,delete,, run
    //**********
    //以下的输出为 create ,, run ,, delete
    //*********************
    People p;
    printf("run");
}

4、执行父类的函数（多态）

Man::Man(int age):People(age,1){
} 
``` 

//接下来是执行一般函数
//在子类的实例中直接调用
```
Man* man = new Man(23);
man->sayHello();//这样只能调用子类的函数
//如果想直接调用父类的函数
man->People::sayHello();  

//有以下两种方式，通过子类调用父类的函数
Man::Man(int age):People(age,1){
    //People::sayHello();
 
}
 
void Man::sayHello(){
    //People::sayHello();
    printf("Man say:Hello C++\n");
};

5、实函数、虚函数

只要一个类中包含 纯虚函数，就可以把它认定为是一个抽象类

一个类中所有方法都是纯虚函数，可认定为一个纯需类-->java接口

 

java里单重继承和多重实现--->c++多重继承

 

实现的时候，最好主体类只是单重继承，而多重实现的时候，实现的父类最好是纯虚类(对应接口)

    People *p = new Man(23);
    p->sayHello();
//指向Man实例的p，执行了People类的方法
//与java不同
//这里会调用People的SayHello方法，而不是Man的SayHello方法

    virtual void sayHello();  
//要想实现在java语言里重写的话
//People 和Man类中SayHello方法全部需要添加virtual

virtual void eat()=0;  
//纯虚函数--->  对应 java抽象方法（本身不实现，由子类实现）

6、运算符重载

class Point
{
private:
    int x;
    int y;
public:
    Point(int x, int y){
        this->x = x;
        this->y = y;
    };
    int getX(){
        return this->x;
    }
    int getY(){
        return this->y;
    }
    void add(Point p){
        add(p.getX(), p.getY());
    }
    void add(int x, int y){
        this->x += x;
        this->y += y;
    }
    void operator+=(Point p){
        add(p);
    }
};

//int main()里面
    //Point p(10, 10);
    //p.add(Point(12, 12));
    //p += Point(13, 12);
//     std::cout << p.getX() << "\n";
    或者
     Point *p = new Point(6, 6);
    (*p) += Point(1, 1);
    std::cout << p->getX() << "\n";  

//终于搞明白了，当创建的是一个实体类的时候，Point p(10,10);这时候调用是 p.getX();
//而指针类的时候，p->getX();

7、伪函数

一个类或者结构体

通过运算符重载，重载了()

看起来好像是一个方法一样调用

 

可以将一个伪函数像一个变量一样进行传递

 

作为一个方法回调，传给另外的应用程序

将一个类当做一个函数对待

class Hello{
public:
    void operator()(){
        printf("Hello CPP\n");
    }
};  


int main()里面
    Hello h;
    h();  

8、指针

//比较麻烦的一种
class Object{
public:
    void(Object::*sayHi)();
};
class Hello :public Object{
public:
    Hello(){
        sayHi = (void(Object::*)())(&Hello::HelloSayHi);
        (this->*sayHi)();
    }
    void HelloSayHi(){
        printf("Hello CPP\n");
    }
}; 

int main()里面
Hello *h = new Hello();
    delete h;  

//上面的略做精简

class Object;
typedef void(Object::*SayHi)();
class Object{
public:
    //void(Object::*sayHi)();
    SayHi sayHi;
};
class Hello :public Object{
public:
    Hello(){
        //sayHi = (void(Object::*)())(&Hello::HelloSayHi);
        sayHi = (SayHi)(&Hello::HelloSayHi);
        (this->*sayHi)();
    }
    void HelloSayHi(){
        printf("Hello CPP\n");
    }
};  

9、引用

实际上就是传指针，减少内存拷贝

    void add(Point &p){
        this->x += p.x;
        this->y += p.y;
    }

    //相比
    void add(Point p){
        this->x += p.x;
        this->y += p.y;
    }  

10、友元类

将一个类里面的私有成员指定公开给另一个类

相当于Java的friendly

 

C++语言变量不加修饰符默认是私有的(private)

class A{
    friend class B;
    int num;
public:
    A(){
        num = 10;
    }
};
class B :public A{
public:
    B(){
        A a;
        printf("%d\n", a.num);
        //printf("%d\n", num);
    }
};

在int main里面
    B b;