C++/C

 

C语言复习

1.字符，字符串，数组
2.函数地址，函数指针

int myAdd(int a,int b){
    printf("%d\n",a+b);
    return 0;
}

int main(){
    int (*p)(int,int);
    p=myAdd; //或者p=&myAdd;
    p(1,2); //或者(*p)(1,2);
 
}

C++学习

1.函数的参数默认值：调用函数时不传参数则使用默认值。可以前面的参数不给默认值，后面的参数给默认值，反之不可以。

void fun1(int a=1,b=2){}
void fun2(int a,int b=2){}

2..h文件和.cpp文件的拆分，类的声明和实现
3.继承：public,protected,private，权限问题,默认继承是private

class Animal{
public:
int data_pub;
protected:
int data_pro;
private:
int data_pri;
};
class Dog:public Animal{};

在所有继承的情况下，父类中的public，protected变量可以在子类中被访问,private变量只能在父类中访问；
在公有继承的情况下，只有public变量可以被类的外部访问；
在保护继承的情况下，所有变量都不可以被类的外部访问，public 和protected的变量可以被子类访问；
在私有继承的情况下，所有变量都变为私有变量

4.继承中构造函数和析构函数调用的顺序

#include <iostream>
using namespace std;
class C
{
public:
    C(){
        cout<<"C()"<<endl;
    }
    ~C(){
        cout<<"~C()"<<endl;
    }
};

class D
{
public:
    D(){
        cout<<"D()"<<endl;
    }
    ~D(){
        cout<<"~D()"<<endl;
    }
};

class A
{
public:
    C c;
    A(){
        cout<<"A()"<<endl;
    }
    ~A(){
        cout<<"~A()"<<endl;
    }
};

class B:public A
{
public:
    D d;
    B(){
        cout<<"B()"<<endl;
    }
    ~B(){
        cout<<"~B()"<<endl;
    }
};

int main(){
    B b;
    return 0;
}

执行结果

C()
A()
D()
B()
~B()
~D()
~A()
~C()

5.多态：向不同的对象发出同样的消息，不同的对象接受时会产生不同的行为

重载可以看成是一种多态，静态绑定，编译的时候已经决定怎么执行
重载：是同一作用域中，名字相同参数不同
子类的重写：子类重写了父类的函数，默认调用子类的函数，如果要调用父类的函数，要把类标识符写出来
虚函数关键词：virtual
动态绑定：在运行的时候才决定怎么执行
要求：
01.父类定义函数为虚函数，
02.子类重写该虚函数，
03.父类的指针指向子类的对象，父类的引用引用子类的对象
动态绑定具体是怎样实现的？
在父类中加入virtual关键词，则创建对象的时候会多一个指针变量，指向子类的虚函数表，虚函数表中存储了这个子类所有虚函数的实现方法

class Animal{
public:
        virtual void speak(){
        cout<<"animal speak"<<endl;
}
};
class Dog:public Animal{
public:
        void speak(){
        cout<<"Dog speak"<<endl;
}
};

int main(){
        Dog d;
        Animal *p;
        p=&d;
        p->speak();
return 0;
}