学习C++的第四天

1、头文件中的 #ifndef/#define/#endif 防止该头文件被重复引用”
//文件路径名：el_1\hello.h

#ifndef _HELLO /////如果没有定义 _HELLO文件

#define _HELLO /////////////那么定义 _HELLO文件

void Hello(void); ////全局函数声明

#endif

2、头文件一般用于存放函数原型

3、类本质上是C语言中结构体的扩充，类中不但可以包含数据成员，还可以包含函数成员，并规定了对类中成员的三级访问权限

在public中声明的成员可以在程序中自己进行访问

在private和protected中声明的成员可以被 此类的成员函数 及 声明为友元的函数所访问

在protected中声明的成员可以被此类派生的类所访问，而在private中声明的成员则不能被此类派生的类所访问

4、

/////rectangle.h////类的声明放在头文件中

class Rectangle  /////定义一个Rectangle 类
{
private:
int length , width , height;   ////长方体的长宽高
public:
Rectangle(int len,int wd,int ht); ////构造函数。。。。。。。构造函数名与类名相同
virtual~Rectangle(void){}     /////析构函数。。。。。。。。析构函数主要用于含有指针的数据成员中释放动态数据成员
int Volume(void);  ///返回长方体体积的函数-----------------------------改动为int Volume(Rectangle oRectangle)
};

///////rectangle.cpp////////类的实现放在源文件中

# include"rectangle.h"    //切记要用双引号

Rectangle::Rectangle(int len, int wd, int ht)
{
length = len;
width = wd;
height = ht;
}

int Rectangle::Volume(void)   -------------------------改为int Rectangle::Volume(Rectangle oRectangle)
{
return length*width*height;----------------------------改为 return oRectangle.length*oRectangle.width*oRectangle.height;
}

///////main.cpp///////////主函数

# include<stdlib.h>
# include<iostream>
# include"rectangle.h" ////提供类Rectangle的声明
using namespace std;

int main(void)
{
Rectangle a(6,8,9);      利用构造函数 构造一个长方体a   此时传入len=6 wd=8 ht=9 然后再传给length  width height

int v = a.Volume();  因为属于Rectangle类 所以需要a.     利用length width height 计算体积 -------------改为a.Volume(a);
cout<<v<<endl;
system("pause");
return 0;
}

改完后等式仍会成立

5、关于 友元

/////rectangle.h////类的声明放在头文件中

class Rectangle
{
private:
int length , width , height;
public:
Rectangle(int len,int wd,int ht);
virtual~Rectangle(void){}
friend int Volume(Rectangle oRectangle);///////加了个friend 意味着该函数并不属于Rectangle类 
};

///////rectangle.cpp////////类的实现放在源文件中

# include"rectangle.h"

Rectangle::Rectangle(int len, int wd, int ht)
{
length = len;
width = wd;
height = ht;
}

int Volume(Rectangle oRectangle) ///////友元函数 已经在Rectangle类中声明过------区别在于该函数不属于Rectangle类
{
return oRectangle.length*oRectangle.width*oRectangle.height;
}

///////main.cpp///////////主函数

# include<stdlib.h>
# include<iostream>
# include"rectangle.h"
using namespace std;

int main(void)
{
Rectangle a(6,8,9);

int v = Volume(a);因为不属于Rectangle类，所以不需要a.
cout<<v<<endl;
system("pause");
return 0;
}

具体大概有下面两种情况需要使用友元函数：（1）运算符重载的某些场合需要使用友元。（2）两个类要共享数据的时候。

1.2.1优点：能够提高效率，表达简单、清晰。

1.2.2缺点：友元函数破环了封装机制，尽量不使用成员函数，除非不得已的情况下才使用友元函数。

6、c++的一大特性就是重载(overload)，通过重载可以把功能相似的几个函数合为一个，使得程序更加简洁、高效。在c++中不止函数可以重载，运算符也可以重载。由于一般数据类型间的运算符没有重载的必要，所以运算符重载主要是面向对象之间的。

7、C++的参数传递（传给函数）

<1>传值方式：是默认方式，在调用函数时，将实参的值传递给函数局部存储相应参数的副本，函数对副本操作，只改变副本的值，而不会修改实参的值

<2>引用方式：引用方式需要在形参声明时参数名前加上符号&，在调用函数时，被传递的不是实参的值，而是实参的地址，函数通过地址存取实参。C语言通过指针实现。

将数组作为值参传递时，由于数组名实际表示数组的起始存储地址，传递的是数据第一个元素的地址，这样对数组元素的修改本质是对实参数组元素的修改

void swap(int &a,int &b)------------用引用&传递方式b实现
{
int t;
t = a;
a = b;
b = t;
}--------------------------------------对应swap(u,v)---------------int a=1 ;int &ra = a; 则ra=1；-------ra = ra-1；cout<<a;输出0   引用的值改变能改变实参的值

void swap(int *a,int *b)------------用指针传递方式实现
{
int t;
t = *a;
*a = *b;
*b = t;
}--------------------------------------对应swap(&u,&v)

8、DEVC++出现打开文件失败的情况  有可能是32位机子然后却选择了64位的解决方法（右上角）

9、exit()

虽然现在大多数平台下，直接在 main() 函数里面 return 可以退出程序。但是在某些平台下，在 main() 函数里面 return 会导致程序永远不退出（因为代码已经执行完毕，程序却还没有收到要退出的指令）。换句话说，为了兼容性考虑，在特定的平台下，程序最后一行必须使用 exit() 才能正常退出，这是 exit() 存在的重要价值。

0表示程序已经正常执行完毕，而非0值则表示有错误发生，至于非0值具体为多少则由开发者自己定义，比如1代表输入错误，2代表计算错误之类的

 

10、有关C++的动态存储分配

通常定义变量（或对象），编译器在编译时都可以根据该变量（或对象）的类型知道所需内存空间的大小，从而系统在适当的时候为他们分配确定的存储空间。这种内存分配称为静态存储分配；

    有些操作对象只在程序运行时才能确定，这样编译时就无法为他们预定存储空间，只能在程序运行时，系统根据运行时的要求进行内存分配，这种方法称为动态存储分配。所有动态存储分配都在堆区中进行。

当程序运行到需要一个动态分配的变量或对象时，必须向系统申请取得堆中的一块所需大小的存贮空间，用于存贮该变量或对象。当不再使用该变量或对象时，也就是它的生命结束时，要显式释放它所占用的存贮空间，这样系统就能对该堆空间进行再次分配，做到重复使用有限的资源。

 

c++中使用new分配的存储单元必须用delete进行释放

new命令的使用格式：

        new 被建立对象的数据类型

或

        new 被建立对象的数据类型[分配存储单元个数]------数组

 

new命令返回指向被建立对象的指针

 

delete命令的使用格式：

        delete 指向被释放对象的指针

或  

        delete []指向被释放对象数组的指针

 

11、在C++中类与结构的区别在于：在结构中默认的访问权限是public  而在类中默认的访问权限是private。除此之外，类与结构是等价的

 

12、算法应具有以下几种性质：正确性、具体性、有限性、确定性、可读性、健壮性(能对非法数据处理 不应死机或出现异常结果)

 

 

13、间接运算符 *和某元素的地址 连在一起以表示 该元素

14、对于数组a[10]来说  a+i 等价于 &a[i]   所以   *(a + i) 等价于 a[i]      特殊的 a等价于 &a[0]

# include<iostream>
using namespace std;
int main()
{
int a[10];
*(a+1)= 5;
cout<<a[1];
return 0;
}

15、 &a[9] - 3 = a +9 - 3 = a +6 = &a[6]        &a[9] - &a[6] = a+9-a-6=3  除此之外，其他任何对地址的运算操作都是不允许的