C++ c到c++

C到C++

C++相比C语言来说，多了两个核心，五个内容：
		1、面向对象的思维；2、模板（泛型编型）
		1.bool 2.引用 3.内联 4.重载 5.缺省参数
           

变量

数据类型 bool

• 布尔 占1个字节 取值：true false

  bool isMax(int a, int b)
    {
    	return a > b;
    }
             

引用 为变量取别名

• typedef int HP;//为类型取别名
• *三种：乘号，解引用，指针
• &三种：位与，取地址，引用

  void mySwap(int a, int b)//值传递
   {
   	int temp = a;
   	a = b;
   	b = temp;
   }
  
   void mySwap(int *pa, int *pb)//址传递
   {
   	int temp = *pa;
   	*pa = *pb;
   	*pb = temp;
   }
  
   void mySwap(int &a, int &b)//引用传递
   {
   	int temp = a;
   	a = b;
   	b = temp;
   }
             

• 函数的值拷贝，如果是一个结构变量，尽量使用指针
• 在C++里面，除了指针拷贝之外，还可以使用引用。使用指针和引用效率是一致
• 指针和引用的区别：

  1、指针是一个有内存的实体，引用只是一个外号
  2、引用是常量，常量必须初始化赋值
  3、指针可以赋空
  4、指针内存唯一，引用不唯一
             

函数

内联函数

• 通过内存膨胀来减少函数的跳转

  函数前面加关键字inline (空间换时间)

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

• 内联的缺点

  1、如果函数内的函数体代码比较长，不建议内联
    2、函数体内有循环,不建议内联什么时候用内联：简单的赋值语句，及返回数据(函数体极少，使用频率高，用内联)
  
  
  
    int playHp = 0;
    inline int GetIndex(int num)
    {
    	return num % 10;
    }
  
    inline void SetValue(int v)
    {
    	playHp = v;
    }
             

函数重载

1. 函数

   把代码的模块化为工具，以此增加代码的复用性

   int myAdd(int x,int y)//计算两整型数据和的工具函数
    {	
    	return x+y;	
    }
              

2. 函数重载

   一个函数名对应多个函数体，什么情况下构成重载：满足两个条件：

   -函数名一致

   -参数列表不一致

   1.参数对应位置类型不同
    2.参数的个数不同
              

   例如

   int myAdd(int x,int y)   double myAdd(double x,double y)   int myAdd(int x,int y,int z)
    {                        {                                 {
        return x+y;                 return x+y;                    return x+y+z;
    }                        }                                 }
              

   注意：和函数返回值没有关系
3. 重载的应用

   #include<iostream>
    using std::cout;//using namespace std;
    using std::endl;//前一种命名空间方式要安全
    int myAdd(int x,int y)
    {
        return x+y;
    }
    double myAdd(double x,double y)
    {
        return x+y;
    }
    int myAdd(int x,int y,int z)
    {
        return x+y+z;
    }
    int main()
    {
    	cout<<myAdd(1,2)<<endl;
    	cout<<myAdd(1.1,2.2)<<endl;//注意小数在编译过程中，会被看作double类型，float类型需要在小数后加f
    	cout<<myAdd(1,2,3)<<endl;	
        return 0;
    //使用重载函数时，注意类型转换带来的错误
    }
              

函数缺省参数

1. 缺省参数

   函数在定义形参时给出初始值

   int myMul(int x,int y=9)
    {
        return x*y;
    }
              

2. 注意事项

   -参数的缺省只能从后往前，依次缺省，不能从前往后

   int myMul(int x,int y=9,int z)
    {
    	函数体
    }
    //错误的写法
              

   -参数的缺省，在只有定义的情况下可以在写在定义上，如果有声明，只要在声明中缺省，不要在定义中缺省

   #include<iostream>
    using std::cout;
    using std::endl; 
    int myMul(int x,int y=9)；//函数声明
    int main()
    {
    	cout<<myMul(4)<<endl;
        return 0;
    }
    int myMul(int x,int y=9)//函数定义
    {
    	return x*y;
    }
    //编译报错：重定义默认参数 : 参数 2
              

   -函数的参数缺省与重载混合使用时，一定要注意参数缺省导致重载的二义性

   #include<iostream>
    using std::cout;
    using std::endl;
    int myMul(int x,int y)
    {
    	return x*y;
    }
    int myMul(int x,int y,int z=9)
    {
    	return x*y*z;
    }
    int main()
    {
    	cout<<myMul(2,3)<<endl;
   
    	return 0;
    }
    //提示错误：对重载函数的调用不明确
              

3. 缺省参数的应用

   #include<iostream>
    using std::cout;
    using std::endl; 
    int myMul(int x,int y=9)
    {
    	return x*y;
    }
    int main()
    {
    	cout<<myMul(4)<<endl;
    	cout<<myMul(4,6)<<endl;//6会覆盖9
        return 0;
    }