C++（1）（函数，类）

C++：

C++:面向对象的C语言

面向对象（C++）与面向过程（C语言）的区别：

面向对象：强调属性（数据）和行为（方法，函数）
面向过程：强调数据结构与算法

这里着重去了解与c具有差异的部分

输入输出：

头文件：<iostream>

输入：cin：表达式1 >> 表达式2 >> ……

输出：cout：表达式1 << 表达式2 << ……

这里的表达式类似printf，输出文本时加上“”，输出变量时会自动判别，并且使用endl来代替回车

 std::cout << "数字是: " << number << std::endl; // 输出文本和数字

在文件中加上using namespace std;（std命名空间）后，可以省去std::前缀

 cout << "数字是: " << number << endl; // 输出文本和数字

函数的参数传递：

1.值传递：

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

2.引用传递

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

-->引用传递：传递形参时使用引用变量

引用（&）是一种特殊类型的变量，可以认为是另一个变量的别名（使用引用的方法实现被调修改主调，区别与c语言中传地址实现被调修改主调的方法）

注：

1.声明一个引用时，就必须对其进行初始化，使它指向一个已经存在的对象

2.一旦一个引用进行初始化之后，就不能改为指向其他对象

注：

      在函数传参时，不能使用auto（实际上不规定变量关键字时默认auto，交给编译器自己识别），如果参数为auto类型，就意味着其不论传递什么参数都可以，这是我们不期望的，此时报错

void test(auto a)
{}

内联函数：

     一般函数调用：跳转，到函数处调用；内联函数：在编译时把函数嵌入在每一个调用处，这样的话能加快运行速度，内联函数的结构应该比较简单，如果将一个复杂的函数定义为内联函数，会造成代码膨胀，增大开销（有些函数不能使用内联函数处理，如递归）

显式内联：在函数定义处直接使用incline来指定：
 

inline int add(int a, int b)
{
    return a + b;
}

隐式内联：通常发生在类内部定义，函数体非常短小，常用于构造函数与析构函数

带默认形参的函数：

     在定义时给出函数的默认值，此时不传参时其参数为默认值，但是注意，函数获取参数的时候是从左往右来获取，也就是说，我如果只传递一个参数，必然是会传给a的，不能跳过a传给b

int add(int a=0, int b=0)
{
    return a + b;
}

    在相同的作用域内，不能存在参数数量与类型相同的重复定义（两个有一个不同就可以，也就是下文的重载）

    如果写成函数声明的版本，那么其默认值只在声明（.h文件）时写出，不在函数体（.c文件）中写出，不然会发生重定义错误

int add(int a=0, int b=0)  //声明

int add(int a, int b)  //实现
{
    return a + b;
}

函数的重载：

     两个及以上的函数，形参数量或类型不同，编译器根据形参类型与个数，自动判断出调用哪一个函数，这就是函数的重载，需要注意的是，返回值类型不能作为编译器判断重载函数的标准

double add(double a=0, double b=0)
{
    return a + b;
}

int add(int a=0, int b=0)
{
    return a + b;
}

类：

抽象：

抽象，是指一个对具体问题进行，并对一些公共性质进行描述的过程

-->数据抽象（数据）与行为抽象（方法，函数）

简单的时钟程序：

数据抽象：

int add(int a=0, int b=0)

行为抽象：

showtime（）,settime

封装：

实际上就是将数据与方法集合形成类，其中的数据的方法都是类的成员

class Clock
{
public:
    void setTime (int newH, int newM, int newS ) ;
    void showTime ( ) ;
private:
    int hour , minute, second;
};

    在调用时，只能访问关键字public里面的数据与方法，而禁止访问private以及protect修饰的数据与方法

--继承和多态暂时不了解

对象：

类-->抽象（数据类型）

对象-->实体（变量），其实就是定义了一个变量（Class）

定义：类名 对象名（Clock c1;）

访问成员：对象名  数据类型名（c1.hour）

                  对象名  方法名（c1.showtime()）

成员函数的实现：

返回值类型 类名:: 参数表

{

        函数体；

} 

带默认形参的的成员函数：

class Clock 
{
public:
    void setTime (int newH= 0, int newM=0, int newS=0) ;
    …
} ;

内联成员函数（隐式，可以显式）：

class Clock {
public:
    void setfime (int newH, int newM,int news ) ;void showTime ( ) 
    {
        cout<<hour<< " : "<<minute<<" :"<<second<<endl;
    }
private:
    int hour, minute, second;
};

构造函数和析构函数：

构造函数：

构造函数：在对象被创建时利用特定的值构造对象，将对象初始化成一个特定的状态

class Clock {
public:
    clock () {
    /*编译系统生成的隐含的默认构造函数*/
    …
};

有参构造与无参构造：

class Clock {
public:
    clock();        //无参构造
    clock(int j = 0,int m = 0,int s = 0)  //有参构造，带默认参数
    {
        hours = h;
        minute = m;
        second = s;
    }
    //使用参数列表初始化
    clock(int j = 0,int m = 0,int s = 0) : hours(h),minute(m),second(s)
    {
    }
private:
    int hours;
    int minute;
    int second;
};

使用参数列表意味着进行的是初始化，但是在构造方法里赋值仅仅是进行赋值

复制构造：利用引用传递的方法，用于使用一个类对象来进行构造

class Clock {
public:
    clock();        //无参构造
    clock(const Clock &other)  //有参构造，带默认参数
    {
        hours = other.hours;
        minute = other.minute;
        second = other.second;
    }
private:
    int hours;
    int minute;
    int second;
};

析构函数：

      析构函数与构造函数的作用正好相反,它用来完成对象被删除前的一些清理工作,也就是专门做扫尾工作的。析构函数是在对象的生存期即将结束的时刻被自动调用的。它的调用完成之后,对象也就消失了,相应的内存空间也被释放。

      与构造函数相似，它的名称是类名前加~构成

class Clock {
public:
    Clock();   //构造
    ~Clock();  //析构 
private:
    int hours;
    int minute;
    int second;
};