C++基础

1-对象

(1)存储，同一类不同对象，属性值不同，但行为相同，所有函数代码存放在公共区

2-类，C++基本单位

(1)成员变量，除了静态的，不初始化，构造对象时，通过构造函数初始化，或者对象索引初始化等

3-封装，类给我们提供的仅仅是函数接口，好的编程方式，类成员变量是隐藏的。

4-抽象

5-继承，单重继承，多重继承（一子类，多个父类），重复继承（一子类，多个父类，父类们，都继承同一个子类），变量名的处理问题，加类名标识

6-多态

静态多态（重载）模版等，编译时确定

动态多态（虚函数，纯虚函数），运行时确定调用哪个函数

基类对象指针，能指向自己类型，以及子类类型的指针，而子类指针不能反过来指向基类指针

基类对象，可以由子类，自己类型对象赋值，反过来不可以。

一个基类，被多个子类继承，基类有两个函数，一个虚函数，一个普通函数。都被子类重写。现在用基类指针，指向子类对象，调用函数，虚函数因指向子类不同而不同，而不是虚函数，一直调用基类自己的函数实现。（基类必须为指针，用对象不行）

#include <iostream>
using namespace std;

class A
{
public:
    virtual fun()   // 虚函数也可以实现函数体，有虚函数的类
    {             // 不一定是抽象类,纯虚函数不能有实现,有纯虚函数的类一定是抽象类
        cout << "A" << endl;
    }
};

class B:public A
{
public:
    fun()
    {
        cout << "B" << endl;
    }
};

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

int main()
{
    /* 对象，没有多态
    A a;
    B b = B();
    C c = C();
    a = b;
    a.fun();
    a = c;
    a.fun()
    */
    A *a;
    B b = B();
    C c = C();
    a = &b;
    a->fun();
    a = &c;
    a->fun();
    return 0;
}

纯虚函数：其实就是普通虚函数的，限制版，让你不得不多态，基类只能是指针，不能实例化为对象，子类必须实现虚函数，也就多态了。

virtual int fun() = 0;, 类也变成抽象类，（有纯虚函数的类才是抽象类）只能声明指针，不能实例化对象。

基础抽象类的子类都该实现纯虚函数的定义，不然子类也是抽象类。

 

7-构造函数

(1)同类名，public,没有返回值，没有定义，系统用空函数，在创建对象时，隐式调用

(2)可内联，重载，带默认形参

(3)

#include <iostream>
using namespace std;

class POINT
{
public:
    POINT(int xx = 0, int yy = 0);
    ~POINT();
private:
    int x;
    int y;
};

// 定义，xx传值给x，相当于this.x = xx;
POINT::POINT(int xx, int yy):x(xx), y(yy)
{
}

POINT::~POINT()
{
    cout << "析构函数" << endl;
}

int main()
{
    POINT point = POINT(1,3); // 有别于java，对象，程序结束调用析构函数
    POINT *p = new POINT(1,3); // 指针，需要delete p,才会调用析构函数
    return 0;
}

(4)拷贝构造函数， 形参为本类的对象引用  POINT (POINT &point);

使用场合， CPOINT B = A;   函数形参为类对象 fun(A),  函数返回值为类对象return A

(5)派生类构造函数，显式调用基类构造函数，初始化基类成员，

B::B(int x1, char c1, int t1, double z1, int w1):A(x1, c1, t1),第二个基类（） //  这样相当于在函数内，直接调用，也就是传值给基类的
{
// 派生类成员，
this.z = z1;
this.w = w1;
}

(5) 调用顺序，基类到子类

8-析构函数

(1)public, ~开始，无参数，无返回值

(2)一般用于delete成员变量，或者清空等name[0] = ''之类

(3)允许内联，没有声明会系统默认

(4)声明虚函数，delete p,基类指针才能析构实际指向的子类，而子类析构函数，会出发回调知道最后基类析构函数。

(1)public

9-访问权限

用于成员：public(对象访问)， protected(派生类函数访问)，private默认(类本身函数访问)

用于类的继承方式：

public  基类属性照搬，基类private不能被访问

protected public变protect,其他照搬，基类private不能被访问

private public,protected变private, 基类private不能被访问

10-模板

函数模版：1-调用规则，先寻找非模版，若能找到符合，不使用模版，2-没有找模版，3-模版没有找能通过类型转换匹配的，没有报错

template <class T>
void swap(T &x1, T &x2)
{
    T x;
    x = x1, x1 = x2, x2 = x;
}

调用和其他函数一样

类模板

#include <iostream>  // class可用typename代替
using namespace std;

template <class T1, class T2>
class CSore
{
    public:
        CSore(T1 xx, T2 yy);
        T2 get();
        void set(T2 yy);
    private:
        T1 x;
        T2 y;
};

template <class T1, class T2> // 得重复
T2 CSore<T1, T2>::get()
{
    return y;
}

template <class T1, class T2> // 得重复
void CSore<T1, T2>::set(T2 yy)
{
    y = yy;
}

template <class T1, class T2> // 得重复
CSore<T1, T2>::CSore(T1 xx, T2 yy)
{
    x = xx;
    y = yy;
}

int main()
{
    CSore<int, char>csore(56, 'u');  // 创建模版累对象，特殊点，接下来函数的调用，同函数模版
    csore.set('r');
    cout << csore.get() << endl;
    return 0;
}

11-命名空间：解决命名冲突问题，可以定义无名命名空间

#include <iostream>
using namespace std;

namespace one
{
    void fun()
    {
        cout << "funOne" << endl;
    }
}


namespace two
{
    void fun()
    {
        cout << "funTwo" << endl;
    }
}

int main()
{
    one::fun();
    two::fun();
    return 0;
}

12-异常处理

#include <iostream>
using namespace std;

int divid(int x, int y)
{
    if (0 == y)
        throw y;
    return x/y;
}

int main()
{
    try
    {
        cout << "18/3 = " << divid(18,3) << endl;
        cout << "18/0 = " << divid(18,0) << endl;
    }
    catch(int y)  // (...)可用省略号处理
    {
        cout <<  "y不能为:" << y << endl;
    }
    return 0;
}

13-运算符重载

类中
friend ostream &operator<<(ostream &stream, const Employee &employee)；
定义
ostream &operator<<(ostream &stream, const &Employee);
{
cout << employee.name << employee.grassPay << endl;
return stream;
}
friend ostream& operator<<(ostream &stream, const Employee &employee);
ostream& operator<<(ostream &stream, const Employee &employee)
{
cout << employee.name << "$" << setiosflags(ios::fixed) << setprecision(2) << employee.grossPay << endl;
return stream;
}
//不可去掉两个&。

bool Employee::operator>(const Employee& otherEmployee)const
{
return grossPay > otherEmployee.grossPay;
}

. * :: sizeof ?::不可重载

 

返回值类型 operator 运算符 （形参）

{

函数体

}

1-为类函数

2-重载为类的友元函数

#include <iostream>
using namespace std;

class CComplex
{
private:
    double real;
    double image;
public:
    CComplex(double r = 0.0, double i = 0.0)
    {
        real = r;
        image = i;
    }
    ~CComplex(){};
    CComplex operator + (const CComplex &cc)
    {
        CComplex temp;
        temp.real = real + cc.real;  // 注意了，在类里面，real等虽然为private却可以使用。
        temp.image = image + cc.image; // 类里面，声明的对象，不用遵守private等权限
        return temp;
    }
    void fun(const CComplex &cc)
    {
        cout << cc.real << endl;
    }
};
int main()
{
    CComplex c1(3.4, 6.7), c2(5.9, 9.8);
    CComplex c = c1 + c2;
    c.fun(c);  
    return 0;
}

来自为知笔记(Wiz)