35、C++对C语言的非面向对象的扩充

C++对C语言的非面向对象的扩充主要包括
　 －－数据类型的扩充，例如引用类型、无名联合等；
　　－－运算符的扩充，例如范围运算符和自定义运算符等；
　　－－函数的扩充，例如内联函数、重载函数、参数为默认值的函数、参数个数不确定的函数等。
　　1、引用类型
　　引用类型其实就是给某个变量起一个别名，它意味着声明的变量只是其他变量的别名，而不是一个真正的独立变量。当用到引用变量时，使用的将是被引用的变量。引用类型变量的声明形式如下：
　　类型说明 & 引用变量=被引用变量；
例1：

// 引用数据类型
#include<iostream>
using namespace std;
void main()
{
   int y=0;
   int &x=y; //x是y的别名
   y=10;
   x+=1;  //相当于y=y+1;
   cout<<y<<endl;
}

结果为：11
　
例2：

// 引用数据类型
#include<iostream>
using namespace std;
void Swap(int &a, int b) // a 是x的别名，其实还是x
{
   int t;
   t=a;
   a=b;
   b=t;

}

void main()
{
  int x=1,y=2;
  Swap(x,y);
  cout<<x<<endl;
  cout<<y<<endl;
}

　
　　
　　 2、无名公用类型
　　C++扩充的联合体类型，支持一种不需要定义变量就可以直接使用的共用体，而且这种共用体不用初始化，这种共用体被叫做无名共用体。定义格式如下：
　　union {成员变量；}
　　无名公用类型的成员变量也不用再使用“.”运算符和“->”运算来获取，可直接访问，它的成员变量之间仍然是共享存储空间。
　　
例3：

//无名共用体
#include<iostream>
using namespace std;
void main()
{
    union {
       int x;
       char y;  
    };
    y=0;
    x=51;    // 3的ASCII码值是51
    cout<<"\n\''"<<x<<","<<y<<"\''"<<endl;
    y='C';   // C的ASCII码值是67
    cout<<"\n\''"<<x<<","<<y<<"\''"<<endl;
}

　　　
　　 3、范围运算符
　　在 C 语言中，如果一个全局变量与一个局部变量的名字是相同的，那么在局域变量的有效范围内，是无法使用全局变量的。C++提供了一个范围运算符::，用于标志出一个全局变量或者对象。
　　
例4：使用范围运算符来访问被局域变量隐藏的全局变量

//使用范围运算符来访问被局域变量隐藏的全局变量
#include<iostream>
using namespace std;
char c;
char f()
{
    char c;
    c='A';
    ::c='B';
    return c; 
}
void main()
{
    char ch;
    ch=f();
    cout<<"local c in f is "<<ch<<endl;
    cout<<"global c is "<<c<<endl;
    cout<<"global c is "<<::c<<endl;
}

　　　
　　 4、内联函数
　　所谓内联函数，就是当函数被调用时，函数的目标代码被插入到程序中，这样的函数就被称为内联函数。
　　内联函数与其它函数的区别主要在执行过程中机器内部的处理。在使用其它函数时，往往要进行堆栈操作，而如果使用内联函数，它实际上是将代码嵌入到函数调用的位置，减少了堆栈等操作。使用内联函数，主要是为了提高效率。控制结构不能出现在内联函数中。
　　内联函数通过修饰符inline来进行说明。
例5：

//使用内联函数
#include<iostream>
using namespace std;
char c;
inline char f()
{
    char c;
    c='A';
    ::c='B';
    return c; 
}
void main()
{
    char ch;
    ch=f();
    cout<<"local c in f is "<<ch<<endl;
    cout<<"global c is "<<c<<endl;
    cout<<"global c is "<<::c<<endl;
}

　　 定义的内联函数只是在编译成可执行文件后，其可执行文件代码与使用非内联的代码略有不同，从表面上看，其运行结果无不同之处。
　　
　　5、参数带默认值的函数
　　C++语言允许函数的参数带有默认值。定义形式如下：
　　函数类型 函数名(参数类型 参数名=默认值)
　　例如
　　

void print(char c='\n')
{
  printf("%c",c);
}

例6：多个参数条件下使用默认值的情况

// 多个参数条件下使用默认值的情况
#include<iostream>
using namespace std;
#include<math.h>
int Sum(int x=1,int y=10)
{
  if((x<=0)||(y<=0)||(x>y)) 
       return -1;
  int i,temp=0;
  for(i=x;i<=y;i++)
  {
    temp+=i;
  }
  return temp;
}

void main()
{
    int result;
    result=Sum(1,100);
    cout<<"Sum(1,100)= "<<result<<endl;
    result=Sum(1);
    cout<<"Sum(1)= "<<result<<endl;
    result=Sum( );
    cout<<"Sum( )= "<<result<<endl;

}

　　 6、参数个数不确定的函数
　 定义形式如下：
　 函数类型 函数名(参数,…)
　 注意：在定义参数个数不确定的函数时，括号中一定要包括一个省略号。
　 当调用这样的函数时，传递给函数后面的几个参数的类型、个数都是不确定的，这经常会产生一些矛盾，所以，只是提供了这样的机制，并不推荐使用这样的函数。
　 7、函数重载
　 在C 语言中，每个函数都有一个唯一的名字，不同的函数，名字一定不同。即使是功能完全相同，也必须根据参数类型的不同给出不同的函数。例如：　

void printA(char c);
void printB(int i);
void printC(char *s);
void printD(float f);

　　多个函数具有相同的函数名的情况被称为是函数的重载。通过函数的重载，用一个名字就可以处理不同的任务。例如，在C++中，可将上面定义的4个不同名字的函数如下定义：

void print(char c);
void print(int i);
void print(char *s);
void print(float f);

　　 ８、内存管理
　　变量具有自身的存储空间，在传统的Ｃ语言中，可以使用一些函数来对变量占用的空间进行动态管理。在Ｃ＋＋中，则是通过new 和delete操作来进行内存的动态管理。new 操作是新建一个对象并进行内存的分配，delete则是销毁一个对象，回收该对象所占用的内存。
　　使用new操作时，通常情况下先声明一个指针变量，采用下列形式：
　　指针变量 = new 变量类型
　　例如：
　　int *p；
　　p= new int;
　　上面代码先声明了一个整型指针变量，然后将指针p 指向一个新建的存放整型数据的存储空间。
　　
例7：动态管理变量内存

//动态管理变量内存
#include<iostream>
using namespace std;
void main()
{  //定义整型指针变量并动态分配内存
    int *pint= new int;
    *pint = 50;
    cout<<*pint<<endl;
    delete pint;
}

例8：对数组存储空间进行动态管理

//对数组存储空间进行动态管理
#include<iostream>
using namespace std;
void main()
{  //定义整型指针变量并动态分配内存
    int *pint;            //定义整型指针
    pint = new int[20];   //动态分配整型数组的空间
    int iCount;
    for(iCount=0;iCount<20;iCount++)
    {
       *(pint+iCount)=iCount;  //为数组元素赋值    
    }
    for(iCount=19;iCount>=0;iCount--)
    {
        cout<<pint[iCount]<<endl;
    }
    delete [] pint;
}