C++、与C语言的一些变化、新增的一些函数类型、面向对象程序设计的基本特点

C++

面向对象的编程思想万物皆对象

类库：

MFC

opencv

opengl

cout：标准输出流对象

endl：换行符

新的数据类型

bool型：逻辑真假—— true、false

变量的存储类型

auto：变量在定义时由编译器自动推到数据类型（c++11）

注：用auto时必须初始化；不能定义函数形参；但是返回值可以为auto，前面返回值可以写到后面；

这两者是等价的

extern：外部声明；

static：静态变量/函数；

const：将变量变为常量（必须要初始化）；

注：不能拿一个未被const修饰的指针来指向一个被const修饰的变量！！

I/O流

>>标准输入流运算符

<<标准输出流运算符

判断是否为左移右移：看左操作数是否为int型

枚举

c：

c++：，w可以赋初值，整型不能向枚举赋值，枚举可以向整形赋值；

类型转换

static_cast<要转的类型>(变量)：静态转换，常用于数字类型之间的转换，不用于指针

cnost_cast ---- dynamic_cast ---- reintepret_cast

引用传参

引用：某个变量的别名（int &ret;）

void fn(&n);

可以函数体外部修改函数体内部的值

之后尽量使用引用传参（节省内存空间，提高效率）

练习：用引用传参写swap（交换两个变量的值）

#include <iostream>
#include <cstdio>
#include <cstring>
#include "func.h"

using namespace std;

void swap(int &a, int &b)
{
    int tmp = 0;
    tmp = a;
    a = b;
    b = tmp;
}

int main(void)
{
    int i = 10;
    int j = 20;

    swap(i, j);
    cout << i << endl;
    cout << j << endl;

    return 0;
}

引用与指针的区别：

1、引用不占空间，指针占8字节（64位）；

2、引用定义时必须初始化，指针不用；

3、引用被绑定后，这种绑定关系是不能被拆解的，指针可以被拆解；

内联函数

在一般函数前加inline关键字

inline 类型说明符函数名（含类型说明的形参表）

{
语句序列
}

有可能在调用函数时将函数的代码直接展开，不用保护现场和恢复现场，提高代码执行效率但是也有缺点：有可能占用的空间大了。

内联函数分文件编写会有问题，内联函数的函数体应该放在头文件而不是源文件中！！

函数必须有返回值（void也行），否则会报错

带默认形参值的函数

函数在定义时可以预先声明默认的形参值；函数调用者也不知道传什么参数时会使用到；

若函数在头文件声明，源文件定于，则默认形参值应该写在头文件里。

函数重载

允许出现两个或两个以上函数同名但不同参的情况，这些函数之间的关系称为函数重载

编译器会选择一个与主调函数参数类型最匹配的函数进行调用，在代码的修改的方向有很大的帮助

返回值不能作为函数重载的依据；

类与对象

类：数据类型

对象：变量

类和对象的关系？答：抽象（类）与具体（对象）的关系

类内：类的设计者编写代码的地方

类外：类的使用者编写代码的地方

访问权限关键字：

public（公有）：类外可以访问

private（私有）：类外无法访问

protected（保护）：类外无法访问

class Clock
{
public:
    void showTime()
    {
        cout << hour << ":" << min << ":" << sec << endl;
    }
    void setTime(int h, int m, int s)
    {
        hour = h;
        min = m;
        sec = s;
    }
    int hour;
    int min;
    int sec;
};

int main(void)
{
    Clock c;

    c.setTime(12, 05, 37);
    c.showTime();

    //对c的其他访问方式
    Clock *p;
    p = &c;
    p->setTime(11, 11, 11);
    p->showTime();

    //对c的其他访问方式
    Clock &ref = c;
    ref.showTime();

    return 0;
}

面向对象程序设计的基本特点

抽象

认清实物的本质

对客观世界认知的过程，即对要解决的问题的本身认知的过程。

数据抽象：数据

功能抽象：行为

要抽象一个东西，就要懂一个东西

以后写代码要先解决抽象问题：有哪些数据抽象，有哪些行为抽象

封装

难点

将数据抽象和行为抽象打包组成一个有机的整体，这个整体就称为类

class Clock    //class关键字；类名
{              //边界
public:        //外部接口
    void setTime(int newH, int newM, int newS); //方法/代码成员
    void showTime();                            //方法/代码成员
private://特定的访问权限
    int hour, minute, second;                   //属性/数据成员
};             //边界

数据成员：属性

成员函数：方法

使用类的使用者是无法洞察类的内部的，类中相关接口来实现与使用者的交互，接口里面怎么实现则不用细究，将这个过程称为封装。

继承

类和类之间的关系

程序员在保持原有属性的基础上，进行更具体，更详细的说明。

多态

强制多态（强制转换）

重载多态

类型参数化多态

包含多态（虚函数）

面向对象的核心

例：对象的数据类型在程序运行的时候才能被确定，写代码时不知道数据类型是什么，一旦选择数据类型后，函数运行就不能出错。

23种设计模式中22种都用到了包含多态。

练习：

写一个类 class Complex

main.cpp

#include <iostream>
#include "mycomplex.h"

using namespace std;

int main()
{
    Complex c;
    cout << "zhijie" << endl;
    c.setReal();
    c.setImage();
    c.showComplex();

    Complex *p = &c;
    cout << "*" << endl;
    p->setReal();
    p->setImage();
    p->showComplex();

    Complex &ref = c;
    cout << "&ref" << endl;
    ref.setReal();
    ref.setImage();
    ref.showComplex();

    return 0;
}

mycomplex.cpp

#include "mycomplex.h"
#include <iostream>

using namespace std;

void Complex::setReal(double r)
{
    real = r;
}

void Complex::setImage(double i)
{
    image = i;
}

void Complex::showComplex(void)
{
    cout << real << "+" << image << "i" << endl;
}

mycomplex.h

#ifndef MYCOMPLEX_H
#define MYCOMPLEX_H

class Complex
{
public:
    void setReal(double r = 0);
    void setImage(double i = 0);
    void showComplex(void);

private:
    double real;
    double image;
};


#endif // MYCOMPLEX_H