第三节 动态内存分配new和delete

经过调试设置断点，发现new函数其实还是调用的malloc函数。

第四节 引用

一个变量是可以有多个引用的，引用也是可以传递的。 常量是不能有引用的。

当引用作为函数的返回值时。如下的例子//

   int&add(int&a,int&b)    //返回的是a的引用到内存中//

   {

       a=a+b;

       returna;

   }

void main ()

{

   inti,j;

   i=1;

   j=2;

   int&k=add(i,j);     //这是引用的传递了， 是内存的值，但是是a的引用//

   k=888;

   printf("i=%d,j=%d,k=%d",i,j,k);

}

//运行结果：i=888,j=2,k=888

第五讲 初始化函数形参（就是有默认值）

这种默认的形参，必须是从右往左且不能有间隔（就是无默认值）的

有了默认形参，在函数的调用时，就允许了，少赋值几个参数（就是用默认值了被）

第六讲 异常抛出与捕获及处理

三个关键字：

try -----------标识可能出现的异常代码段；

throw----------抛出一个异常；（必须在try代码块中，其后面的值决定了抛出异常的类型，类似switch--case）

catch-----------标识处理异常的代码段；（会有多个，类似switch--case）

提示：

使用异常处理将带来更多的系统的开销，因此慎用异常//

第七讲 函数重载

条件：函数名相同，但是：函数的参数类型不同（用函数模板最好了），或者参数个数不同。

数组a的长度（元素的个数）是：sizeof(a)/sizeof(int)

inta[6]={1,2,3,4,5,6};

第八讲 函数模板

使用函数模板可以简化形参个数相同，而类型不同的函数；

函数模板的使用：

Template < typename T>  //可以用class替换 typename

例子： 求数组中元素最大值的函数；

template<typenameS>

Smax(Sarray[],intlen)

{

   Simax=0;

   for(inti=0;i<len;i++)

   {

       if(array[i]>imax)

       {

           imax=array[i];

       }

   }

   returnimax;

}

int_tmain(intargc,_TCHAR*argv[])

{

   inta[6]={1,2,3,4,5,6};

   floatb[5]={1.0f,2.0f,3.3f,5.5f,4.4f,};

   printf("数组a最大值为%d\n",max(a,sizeof(a)/sizeof(int)));

   printf("数组b最大值为%f",max(b,sizeof(b)/sizeof(float)));

   getchar();

   return0;

}

第九讲 类的初识

构造函数：

成员函数的实例化位置，在类中直接完成就是内敛函数了。 正常应该是在类的外面完成的。

类的声明是在 .h文件中，类的实现是在.cpp文件中。 主函数在一个 .cpp文件中

在vs中新建这些类，  可以用提供的菜单功能。简单。（函数也是可以的）

第十二讲 访问类的私有成员

类的私有成员：

用private声明的变量或者函数。  只能在本类中使用，不能在其他类或者本类以外的位置调用、访问。  ；

用public定义的变量或者函数可以在整个程序中调用访问。

访问类的私有成员（读取）：

    可以通过定义本类的成员函数，来访问本类的成员变量。

Inline 内敛函数：

内敛函数的声明？？？？？？？？？？？？？

函数实现时，如果不是在类中， 那么也要和类的声明在同一个文件中。

第十三讲 默认赋值构造函数

三种情况：

1、类的对象赋值初始化另外的类对象（类肯定是一个了）

2、函数的 参数传递（类对像之间）

3、函数的返回值是类的对象。

第十四讲 友元函数

友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。通常同一个开发者会出于技术和非技术的原因，控制类的友元和成员函数（否则当你想要更新你的类时，还要征得其他部分的拥有者的同意）。

在类中声明这个友元函数：

friend +函数的声明格式；

（大）堆malloc、new

（小）栈函数

C语言中的指针：多用于以下的内容

 Int m_nSize=…;

 Int * pNum= (int *) new BYTE[m_nSize];  //字节//

pNum[10]=…….

赋值为NULL或0的指针，声明时是有类型的，只是不指向任何有效的地址。

Void类型的指针，可以指向任何类型。

第十五讲 this指针(几乎所有面向对象语言都有，我目前接触的是这样)

this指针可以看成是实例化对象的地址。在类成员函数里访问成员变量，其实也隐含使用了this指针。

一个问题：

class Tdate

{

int Year;

intMonth;

intDay;

public:

Tdate(intYear,int Month,int Day) 

{

        Year= Year;     //这里是有问题的： 我们想给类的成员变量赋值，但是对不把。

        Month= Month;

        Day= Day;

}

};

更改如下：

Tdate(int Year,int Month,int Day) 

{

        this->Year=Year;     //这里是有问题的： 我们想给类的成员变量赋值，但是对不把。

        this->Month=Month;

        this->Day=Day;

}

第十六讲 类的const对象

1. 类的const对象

const意味着只读，意味着所标识的类成员变量不能出现在=号的左边；构造、析构函数除外。

这样的类对象，只能访问const修饰的成员函数，其他成员函数访问不了。

class Tdate;

const Tdate dt(1998,8,19);

1. const修饰成员函数（实现和声明都要有！const）

const放在函数的尾部。不能修饰构造函数。

第十七讲 类的对象数组

我们声明类对象的数组，与我们声明内置类型（ing,float）数组的方式完全相同。

int b[3];

Tdate d[2];  调用默认构造函数了。

int b[3]={1,2,3};

Tdate d[2] ={Tdate(1999,1,29),Tdate(2000,3,45)};   //用构造函数呗

Tdate d[10]={Tdate(1999,1,29),Tdate(2000,3,45)}; //后面没有赋值的8个调用了构造函数了。

第十八讲 类静态数据成员（是属于类的，可以用类：：访问）

静态成员的提出是为了解决数据共享的问题。实现数据共享有许多的方法，如：设置全局性的变量或者对象是一种方法。但是，全局变量或对象是有局限性的。这一课，我们主要讨论用类的静态成员了来实现对象间的数据共享。

一、类静态数据成员

1. 静态数据成员在定义或说明时前面加关键字static。

2. 静态成员初始化与一般数据成员初始化不同。其格式如下：

<数据类型><类名>：：<静态数据成员名>=<值>；

3、静态数据成员是静态存储的，他是静态生存期，必须对它进行初始化。

4、引用静态数据成员时，采用如下格式：

<类名>：：<静态成员名>;

例如，可以用类的静态成员函数存放用于存放类的实例化次数(对象个数)

哪怕没有对象的实例也是可以访问的。

二、类静态成员函数

静态成员函数内不能使用非静态类成员数据。

类成员函数可以独立使用。

可以使用类+作用域解析符调用静态成员函数，如Tdate::staticFun();

最好把成员函数的实现放在.cpp里边，以防止重复定义。（因为.h文件可能被多次的引用）。静态的东西被多次的编译是会出错的。

第十九讲 类对象指针

定义类对象的指针：

Tdate d1; //对象

Tdate *p1 = &d1;

Tdate *p2 = (Tdate *)malloc(sizeof(Tdate));

Tdate *p3 = new Tdate;

如果：我

Tdate * p = NULL;   

Int n=p-> year;  //没有指定的存储空间，非法了，除非year是静态类型的变量。