C++的学习日记2（函数重载）

面向过程（思想）：以什么正在发生为目标（强调的是算法）
缺点：不容易维护，灵活性差，不容易扩展，不能复用；
面向对象：以什么正在受影响为目标（建模）
耦合度：模块与模块存在的联系（越低越好） 多态

可复用，耦合度低（职责分离）

封装：把“数据（属性）”和“函数（操作）”合成一个整体

内联函数
关键字 inline 必须加在函数定义之前，放在函数声明之前无效
内联函数不需要像函数调用一样 寻址、压栈、出栈
编译器直接将使用相应的函数代码替换函数调用
优势 内联函数不需要像函数调用一样 寻址、压栈、出栈
节省开销

内联函数 “副本”
如果一个内联函数被多次调用 （假如一个函数被在不同地方调用10次，那就有10个副本）
应该有选择的使用内联函数？
如果代码执行的时间比处理函数调用机制时间更久，则节省的时间只占整个过程一小部分，那就…

限制：1.避免内联函数被多次调用
	  2.不能使用循环、条件语句、递归，取址（函数体不能过大）

内联函数 和 宏定义的区别：（为什么要用内联函数）
1.（何时处理）宏定义在预编译阶段处理，内联函数在编译的时候展开；
2.编译时候，内联函数可以直接被镶嵌到目标代码；
宏定义-文本替换；
3.内联函数（本质还是一个函数） 类型检测，（语句是否正确）；宏定义不具备
4.宏定义不是函数，内联函数本质还是一个函数
5.宏在定义的时候要小心处理宏参数（防止二义性）

#include <iostream>
#define spow(x) x*x

using namespace std;

inline int pow(int x)
{
  return x*x;
}

int main()
{
  cout<< "spow(2+3) = "<< spow(2+3)<< endl;
  cout<< "pow(2+3) = "<< pow(2+3)<< endl;

  return 0;
}

函数默认参数：
当函数调用没有指定某个参数的值，编译器会自动用默认值代替
从右向左添加默认值（默认值必须放在末尾）

函数重载
用同一个函数名定义不同的函数
保证他们特征标不同：
特征标：如果两个函数他们的参数列表 数目相同/类型相同/参数顺序相同
条件：满足三者其一
数目不同；
类型不同；
顺序不同；
注意点：返回值是不能作为函数重载的条件

当函数重载遇上默认参数：
会产生二义性

函数重载机制：（静态联编：在编译的时候就已经全部确定好要用哪个函数）
1.将所有同名函数作为候选者
2.尝试寻找可行的候选方案：
1精确匹配
2通过默认参数能够匹配的函数
3通过默认类型转换匹配的
3.匹配失败：
二义性/没有候选者

封装：把“数据（属性）”和“函数（操作）”合成一个整体
1.把属性和操作封装；
2.把属性和操作进行访问控制。

成员变量：数据（属性）
成员函数：函数（操作）

设置权限：
1.public：公有
2.private：私有
3.protected:被保护的（继承）(如果没有继承 和private相同)

class 和 struct区别：
c语言中struct没有成员函数，C++中可以有成员函数；
C++中 class 和 struct区别：
（c++语言中struct有成员函数）
权限：Class中如果没有声明权限，默认private;
struct中如果没有声明权限，默认public;
class还可以用来表示模板类型；struct不具备；

构造函数 析构函数

构造：
是什么？ 函数名是与 类名相同 的特殊成员函数
什么时候执行？ 在每次创建对象的时候执行
作用？ 在创建对象的时候初始化
形式？ 函数名是与 类名相同
在定义时候可以有参数
没有任何返回值（void也不行）
cuboid(<参数列表>)
怎么调用？ 大部分情况是自动调用，少部分情况手动调用

析构：
是什么？ 函数名是与 类名近似 的特殊成员函数
什么时候执行？ 在每次销毁对象的时候执行
作用？ 清理对象
形式？
在定义时候不可以有参数
没有任何返回值（void也不行）
~cuboid(<参数列表>)
怎么调用？ 自动调用

#include <iostream>
using namespace std;

class Cuboid
{
private:
    int a, b, c;
public:
    Cuboid(int x, int y, int z);
    ~Cuboid();

    int geta()
    {
        return a;
    }

    int getb()
    {
        return b;
    }

    int getc()
    {
        return c;
    }

    int getS();

    int getV();
};

Cuboid::Cuboid(int x, int y, int z)
{
    a = x;
    b = y;
    c = z;
    cout<< "构造函数已调用！"<< endl;
}

Cuboid::~Cuboid()
{
    cout<< "析构函数已调用！"<< endl;
}

int Cuboid::getS()
{
    return (a * b + a * c + b * c) * 2;
}

int Cuboid::getV()
{
    return a * b * c;
}

int main()
{

    Cuboid cuboid(3, 4, 5);
    cout<< "长方体的信息如下："<< endl;
     cout<< "长："<< cuboid.geta()<< "|"<< "宽："<< cuboid.getb()<< "|"<< "高："<< cuboid.getc()<<endl;
     cout<< "表面积："<< cuboid.getS()<< "|"<< "体积："<< cuboid.getV()<<endl;

    return 0;
}

初始化 赋值
int a = 1; 初始化

int b;
b = 2; 赋值

存在三个默认的函数
1.默认构造函数 什么事都不做但依然会执行
2.默认的拷贝构造函数 将obj中所有成员变量的值赋给当前对象所有成员变量
3.默认析构函数

拷贝构造函数
test t1(1,2); 调用构造函数

test t2 = (3,4);  
t2 = t1;         调用的是拷贝构造函数

形式 test(const test& obj)

何时调用？（1，2）
1.一个对象需要通过另一个对象进行初始化的时候 cuboid c2 = c1;
2.一个对象以值传递的方式传入函数体（作为参数）
3.一个对象以值传递的方式从函数返回（作为返回值）

#include <iostream>
using namespace std;

class Cuboid
{
private:
    int a, b, c;
public:
    Cuboid(int x, int y, int z);
    Cuboid(const Cuboid & obj);
    ~Cuboid();

    int geta()
    {
        return a;
    }

    int getb()
    {
        return b;
    }

    int getc()
    {
        return c;
    }

    int getS();

    int getV();

    int func1(Cuboid obj);

    Cuboid func2();
};

Cuboid::Cuboid(int x, int y, int z)
{
    a = x;
    b = y;
    c = z;
    cout<< "构造函数已调用！"<< endl;
}

Cuboid::Cuboid(const Cuboid& obj)
{
    a = obj.a;
    b = obj.b;
    c = obj.c;
    cout<< "拷贝构造函数已调用！"<< endl;
}

Cuboid::~Cuboid()
{
    //cout<< "析构函数已调用！"<< endl;
}

int Cuboid::getS()
{
    return (a * b + a * c + b * c) * 2;
}

int Cuboid::getV()
{
    return a * b * c;
}

int Cuboid::func1(Cuboid obj)
{
    cout<< "拷贝构造函数已作为参数的形式调用！"<<endl;
}

Cuboid Cuboid::func2()
{
    Cuboid cc(1, 1, 1);
    cout<< "拷贝构造函数已作为返回值的形式调用！"<< endl;
    return cc;
}

int main()
{

    Cuboid c1(3, 4, 5);
    Cuboid c2 = c1;
    cout<< "长方体的信息如下："<< endl;
    cout<< "长："<< c2.geta()<< "|"<< "宽："<< c2.getb()<< "|"<< "高："<< c2.getc()<<endl;
    cout<< "表面积："<< c2.getS()<< "|"<< "体积："<< c2.getV()<<endl;

    c2.func1(c1);
    c2.func2();

    return 0;
}