c++第一节课

c++第一节课

引用

引用的定义
类型& 引用变量名称 = 变量名称;
1.引用相当于给变量重新起了个名字
eg

int main()
{
 int a = 10;
 int b = a;
 int& d = a;   //可以通过d改变a的值
 const int& x = a;   //常引用，无法通过x更改a的值
 return 0;
}

2可以在函数传参数时使用

void Swap(int& a, int& b)
{
int c = a;
a = b;
b = c;
}
int main()
{
int x = 10, y = 20;
Swap(x, y);
return 0;
}

inline 函数（内联函数）

在 C++ 中，为了解决一些频繁调用的小函数大量消耗栈空间（栈内存）的问题，特别的引入了 inline 修饰符，
表示为内联函数。

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

内联函数的处理方式是在函数的调用点直接代码展开。在计算机系统下，假如频繁的调用就会造成较大的时间开
销。内联函数的引入减少了函数调用过程中开栈和清栈的开销。处理流程如下图所示：

 int Max(int a, int b)
 {
 return a + b;
 }
 int main()
 {
 int a = 10;
int b = 20;
 int rt = 10 + 20;
 cout <<"rt : " << rt << endl;
return 0;

}

内联函数和普通函数的区别
内联函数在调用点代码直接展开，没有开栈和清栈的开销。普通函数有开栈和清栈的开销。
内联函数体要求代码简单，不能包含复杂的结构控制语句。
如果内联函数函数体过于复杂，编译器将自动把内联函数当成普通函数来执行。

函数的默认值

函数的默认值只能倒叙写，即从右向左

// void fun(int a,int b = 0 ,int c ,int d = 0 ,int e=10) // error
void fun(int a, int b = 0, int c = 0, int d = 0, int e = 10)
{
 printf("a = %d b = %d c = %d d = %d e = %d \n", a, b, c, d, e);
}
int main()
{
fun(12);
fun(12, 23);
fun(12, 23, 34);
// fun(12,,34); error;
 return 0;
 }

函数的重载（编译时确定）

C++中对函数区分是用 函数原型 区分的（不包括返回类型）
C语言用函数名区分
函数原型 返回值 函数名 形参列表（其中形参名可以省略），且不需要函数体。

模板函数

函数模板定义如下：
template<模板参数表>
返回类型 函数名(形式参数表) {
//函数体
}
eg

template<class Type>
const Type& Max(const Type& a, const Type & b)
{
return a > b ? a : b;
}
int main()
{
int x = Max(12, 23);
char ch = Max('a', 'b');
double dx = Max(12.23, 34.45);
return 0;
}

这里函数分别在编译时改为

typedef char Type;
const Type & Max(const Type &a,const Type &b)
{
return a > b ? a : b;
}

new/delete 和 malloc/free 区别

使用maolloc需要引入 <stdlib.h>

//申请失败返空
int *p = (int*)maoloc(sizeoff(int)); (maolloc是函数)
//申请失败返回 throw bad_alloc
int* ip = new int(1);(new是关键字)  //初始化为1

int *ipp = new int[n](1); //开辟n个空间,每个都初始化为1

free(p);
delete ip;
delete []ipp; //方括号告诉编译器删除的是连续空间

new别用法

//两个申请失败均返回 抛出异常
int *pa = new int(10);  //开辟空间并初始化
int *p = (int*)::operator new(sizeof(int)) //开辟空间
operator delete(pa);
//               malloc

new（p） int(10);  //不开辟空间，用10初始化p开辟的空间

空悬指针：释放掉的指针，仍然指向那个地址，完了一定要置空
野指针：未初始化的指针

namespace

为了解决命名冲突的问题，C++提供了名字空间作用域的机制。
全局名字污染问题
namespace 名字空间作用域名称
{

}
eg

namespace ndt
{
int a;
 int Sum(int a, int b)
 {
return a + b;
 }
 }

访问方式如下

int main()
{
 cout << ndt::a << endl;
int rt = ndt::Sum(10, 20);
 return 0;
 }

除了上述的访问方式外，c++还有另外两种访问方式
1.using声明
using 声明是将 using 声明后面的符号暴露在当前 using 声明所在的作用域。

int main()
 {
using ndt::a;
using ndt::Sum;
cout << a << endl;
int rt = Sum(10, 20);
return 0;
 }

2.using 指示符

using 指示符是将 using 指示符后名字空间作用域下的所以符号暴露在 using 指示符所在的作用域。因为 using 指示符会导致名字空间作用域被污染。所以我们在编码过程中并不提倡使用 using 指示符。

int main()
{
using namespace yhp;
cout << a << endl;
int rt = Sum(10, 20);
return 0;
} 

附：
同名的名字空间作用域会进行合并。合并成一个名字空间作用域，包含所有名字空间作用中的内容。