C++学习笔记（三） 域运算符 new delete运算符 重载 name managling与extern"c" 带默认参数函数

内容概括：

域运算符
new、delete运算符
重载
name managling与extern “C”
带默认参数的函数

一、域运算符

C++中增加的作用域标识符 ::
1.用于对与局部变量同名的全局变量进行访问

#include <iostream>
using namespace std;

int var = 100;
int main(void)
{
	int var = 50;
	cout<<var<<endl;
	cout<<::var<<endl;
	return 0;
}

2.用于表示类的成员，这将在关于类的一节中详细说明

二、new delete 运算符

new运算符可以用于创建堆空间
成功返回首地址，失败抛出异常，故不用检测是否为null
语法：
指针变量=new 数据类型;
指针变量=new 数据类型[长度n];
例如：

int* p = new int;			//分配一个整数空间 4字节
int* p1 = new int(33);			//分配一个整数空间 4字节,初始值为33
int* p2 = new int[10];		//分配连续的10个整数空间 40字节

delete运算符 可以用于释放堆空间语法： 

delete 指针变量；

delete [] 指针变量；

例如：

delete p;
delete[] p2;

new一个新对象:
内存分配(operator new)
调用构造函数
delete释放一个对象:
调用析构函数
释放内存(operator delete)

补充：

1. c语言中 malloc 只做内存分配，不调用构造函数

2. new的作用

三、重载

相同的作用域，如果两个函数名称相同，而参数不同，我们把它们称为重载overload
函数重载又称为函数的多态性

函数重载不同形式：
形参数量不同
形参类型不同
形参的顺序不同
形参数量和形参类型都不同

调用重载函数时，编译器通过检查实际参数的个数、类型和顺序来确定相应的被调用函数

合法的重载例子：

int  abs(int i);
long abs(long l);
double abs(double d);

非法的重载例子：

int  abs(int i);
long abs(int i);
void abs(int i);

//如果返回类型不同而函数名相同、形参也相同，则是不合法的，编译器会报"语法错误"。

四、name managling 与 extern"c"

name managling这里把它翻译为名字改编。
C++为了支持重载，需要进行name managling

extern “C”实现C与C++混合编程

//extern "C"表示不进行名字改编
#ifdef __cpluscplus //表示如果是C++语言则extern"c"，C语言则无需extern"c"
extern "C"
{
#endif
void fun(int a)
{
	cout<<"xxxx"<<endl;
}
void fun2(double a)
{
	cout<<"yyyy"<<endl;
}
#ifdef __cpluscplus
}
#endif

五、带默认形参值的函数

函数声明或者定义的时候，可以给形参赋一些默认值
调用函数时，若没有给出实参，则按指定的默认值进行工作

函数没有声明时，在函数定义中指定形参的默认值
函数既有定义又有声明时，声明时指定后，定义后就不能再指定默认值    

报错： error C2572: “fun”: 重定义默认参数 : 参数 1

默认值的定义必须遵守从右到左的顺序，如果某个形参没有默认值，则它左边的参数就不能有默认值。

void func1(int a, double b=4.5, int c=3); //合法 
void func1(int a=1, double b, int c=3);  //不合法

函数调用时，实参与形参按从左到右的顺序进行匹配

六、带默认形参值的函数的二义性

int add(int x=5, int y=6); 
int add(int x=5, int y=6, int z=7); 

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

int main() { int sum;sum= add(10,20); return 0;}

sum=add(10,20)语句产生二义性性，可以认为该语句是调用第一个函数，也可以是第二个，因此编译器不能确定调用的是哪一个函数。