C++ 五课时入门教学

我不是女神ヾ 2024-04-19 13:55 67阅读 0赞

第一课      C++ 概述

一.引言  
            
          1、计算机程序  
               是用计算机程序设计语言所要求的规范书写出来的一系列动作，               它表达了程序员要求计算机执行的操作。

2、程序设计语言  
               是用来描述计算和事务处理过程、便于计算执行的规范化语言。

3 、程序设计  
               是一种编写计算机程序的活动。

二.程序设计的演变  
            
           计算机语言的发展：  
          (1)、机器语言（第一代）  
              机器语言使用最原始的机器指令，这些指令由一串二进制的数表              示(即0 和 1)，能直接被计算机识别和运行。  
          (2)、汇编语言（第二代）  
              汇编语言将机器指令映射为一些能被人读懂的助记符（如             ADD,SUB)，用汇编语言写成的源程序被转换成机器指令然后执行。  
          (3)、高级语言（第三代）  
              与具体机器无关的语言，只按语法编写程序即可。

程序设计的演变:

1 早期的程序设计(fortran,basic)：  
                         程序的控制随意跳转，无限制的使用GOTO语言  
           2 结构化的程序设计(Pascal,C)  
              主要思想：自顶向下 逐步求精 采用单入/出口的控制结构

结构化程序设计的结果是使一个结构化程序最终由若干个过程组成，           每一过程完成一个确定的功能。      
      
                  
           3 面向对象的程序设计(C++,Java,C\#)----本质  
                 把数据和处理数据的过程当作一个整体---对象  
            类和对象的区别:   
               对象是类的实例化 ，类仅仅是一种设计，对象是由这种设             计而生成的实例   
                对象=======现实世界的一个实体    
                 
               类为程序的基本单位，具有封装，数据抽象，继承，多态性  
               类============描述一群实体的共同属性与性为  
                 
          面向对象程序设计的主要特征：  
          1、封装和数据隐藏  
          2、继承和重用  
          3、多态性

.............................................................................................................................  
                   
        三. C++ 简介

1、C++的概念  
C++是一种广泛应用的程序设计语言，它在C语言的基础上扩展了面向对 象的程序设计特点。最主要的是增加了类功能，使它成为面向对象的程序设计语言，从而提高了开发软件的效率。

2、C++发展历史  
    1972年-1973年间出现了C语言，设计C语言的最初目的是编写操作系统。由于其简单、灵活的特点，C语言很快被用于编写各种不同类型的程序，从而成为世界上最流行的语言之一。  
   C++语言是对C语言的扩充或称为C语言的超集，他继承了C语言高效、灵活的特点，扩充了面向对象程序设计的支持。  
   目前C++语言尚未完成标准化工作，基本上已AT&T贝尔试验室公布的文本为标准。  
  C++语言是一门还在发展的语言。

3、C++语言的程序结构  
\*注释      “//”     “ /\* ”      “ \*/ ”  
\*编译预处理：  
    (1)、文件包含命令  \#include   
（\#include<文件名>,\#include “文件名”)  
    (2)、宏定义命令（在C里常用）\#define   
    (3)、条件编译命令（ 协调多个头文件）\#if \#else  
\*程序体  
  函数（主函数）  
  变量  
  类

(1)main() 函数在C++程序中是强制的。

(2)当main()函数完成执行时，通知return 0语句来通知操作系统关于它的完成。  
     
(3)操作系统考察返回给它的数0，表示程序执行已经完成且没有错误；如果返回     给操作系统的是任何非0的数，这说明已出现了某种错误。

4、C++语言程序运行  
通过编译器编译后的 \*.obj文件称为程序的目标代码(Compile).  
将编译生成的目标代码文件经过链接成为可执行文件 \*.exe (Build).

\#include <iostream>//文件包含命令（预处理命令的一种）  
 using namespace std;//对于使用了标准C++库定义的函数、类和对象的程序，                      严格符合标准的编译器都要求使用这条指令。  
int main()  
 \{  
   cout << “Hello world!”<<endl;//标准C++库定义的一个类ostream（与标                    准输出设备关联）的对象。//引导数据到标准的输出设备  
   return 0;  
 \}

对象:  
   取钱:柜员机.取款人.远程服务器  
   面向过程的编程语言  
   OOP技术  
   C++ 具有强大的强大功能  
     
面向过程.基于对象  
面向过程和面向对象的关系：  
面向对象包容面向过程

C++程序设计语言 :    和硬件联系紧密    
                     C语言广泛，是一种底层工作语言  
                     扩展了面向对象程序特点           
                     增加了类的功能  
C++ 发展史(C,C++,C\#)：  
   C语言       最初动机：编写操作系统     
               优点：    简单、灵活  
   C++         C语言的扩充   
               优点：高效、灵活   扩展了面向对象程序设计  
C++ 简介

小结:  
1、计算机程序  
2、程序设计语言  
3、程序设计  
4、计算机语言的发展  
5、程序设计的演变  
      早期的程序设计/结构化程序设计/面向对象的程序设计  
6、C++的概念  
7、C++的发展史  
8、C++程序的结构  
9、C++程序的运行

.............................................................................................................................  
编写简单的C++程序  
对象创建和调用成员函数的源代码例

1.编写输入价格的程序price.cpp  
\#include <iostream >  
using namespace std;  
class car   
\{  
 float price;  
 public:  
 void acceptprice ()  
 \{   
     cout <<"Enter Price :12";  
     cin >>price ;  
\}  
void honk()  
\{  
 cout <<"BEEP BEEP !";  
\}  
\};  
int main ()  
\{  
    car ford ;  
    ford .acceptprice ();  
    ford .honk();  
    return 0;  
\}

2. 编写输出 'Hello world'的程序（endl操纵符）helloworld.cpp

\#include<iostream>  
using namespace std;  
int main()  
\{  
    cout<<"Hello  world!"<<endl;  
    system("pause");//让屏幕暂停  
    return 0;   
\}

3.编写三个数相加的程序  
\#include<iostream>  
using namespace std;  
int main()  
\{    
     int x,y,z;  
    cout<<"请输入一个数:";  
    cin>>x;  
    cout<<"请输入第二个数:";  
    cin>>y;  
    cout<<"清输入第三个数:";  
    cin>>z;  
    cout<<"三个数之和等于:"<<x+y+z<<endl;  
    //cout<<"Hello  world!"<<endl;  
    system("pause");//让屏幕暂停  
    return 0;   
\}

4.编写输入两个数据的程序  
\#include <iostream>  
(using namespace std;)  
int main()  
\{  
    std::cout <<"Enter two numbers:"<< std::endl ;  
    int v1,v2;  
    std::cin >>v1>>v2;  
    std::cout<<"The sum of "<<v1<<" and "<<v2<<" is "<<v1+v2<<std::endl ;  
    return 0;  
\}

第二课           创建对象和类

一、创建类  
1、类的声明  
类的命名规则：  
◆类名必须是有效的标识符，关键字不可用作类名。  
◆类名应该是名词并且有意义。  
◆类名的首字母应该大写。若两个单词，每一单词的首字母都大写。

2、声明类内的成员变量  
格式： 数据类型     变量名;  
class Car  
\{  
        float  price;  
        ……  
\}；

数据类型:  
数据类型告诉编译器要为变量分配多少内存空间。  
1).基本数据类型  
整型： int  
字符型： 单字符型 char、宽字符型 wchar  
实型：   单精度型 float、 双精度型 double

2).复合数据类型（用户自定义数据类型）  
数组     type\[\]  
指针     type \*  
空类型   void  
结构     stuct  
联合     union  
枚举     enum  
类         class

3).常用基本数据类型  
类型 说明 长度(字节) 表示范围  
char 字符型 1 -27 ~  27 -1  
int 整型 4 -231 ~  231 -1  
float 浮点型 4 -3.4\*1038 ~ 3.4\* 1038 –1  
(7位有效位）  
double 双精度型 8 -1.7\*10308 ~ 1.7\* 10308 –1  
(15位有效位）

变量:  
变量提供了程序可以操作的有名字的存储区。C++的每一个变量都有特定的类型，该类型决定了变量的内存大小和布局、能够存储于该内存中的值的取值范围以及可应用在该变量上的操作。  
对于每一个变量，都有两个值与其相关联：  
a.它的数据值，存储在某个内存地址中。  
b.它的地址值，即，存储数据值的那块内存的地址。

变量的定义:  
变量的定义会引起内存的分配。  
\*一个简单的对象定义由一个类型指示符后面跟一个名字构成，以分号结束。如：  
double dalary;  
double wage;  
int day;  
int year;  
\*一个简单的定义指定了变量的类型和标识符，它并不提供初始值。如果一个变量是在全局域内定义的，那么系统会保证给它提供初始值0。  
\*如果变量是在局部域内定义的，或是通过new表达式动态分配的，则系统不会向它提供初始值0。这些对象被称为是未初始化的。未初始化的对象不是没有值，而是它的值是未定义的。

C++支持两种初始化  
第一种形式是使用赋值操作符的显式语法形式：  
int ival=1024;  
string project="hello world";  
在隐式形式中，初始值被放在括号中：  
int ival(1024);  
string project("hello world");  
每种内置数据类型都支持一种特殊的构造函数语法，可将对象初始化为0。如：  
int ival=int();  
double dval=double();

C++中命名变量的规则：  
◆变量名必须是有效的标识符，关键字不可用作变量名。  
◆变量名应该是名词并且有意义。  
◆变量名的首字母应该小写。若多个单词，每一单词的首字母都大写。  
◆变量名必须是唯一的。  
注：C++是大小写敏感的语言

引入数组   
数组是C++中的内置数据结构。数组有一些严重的缺陷，除非有必要，不要大量的使用数组。  
数组是某种特定类型对象的集合。  
数组：是存储在相邻内存单元中的统一数据类型的元素的集合。  
数组的声明：  
<数据类型>   <数组名>\[<维数大小>\]；  
数组的初始化：  
<类型> <数组名>\[<维数大小>\]=\{值1，值2，… 值N \}；

(1)、数组的所有元素必须具有同样的数据类型。  
(2)、在对数组进行初始化之前，必须定义它的数据类型。  
   数组变量的定义和初始化可以出现在同一个语句中。  
   数组如果在声明时不进行初始化必须说明数组的大小。  
(3)、数组的第一个元素下标从0开始。数组的每个元素可通过它的下标数来访问。  
(4)、C++不支持数组之间的直接赋值，只能一个一个元素地赋值。  
(5)、C++语言中，编译和执行时并不检查数组下标是否越界。所以，使用数组时需要特别注意检查下标是否越界。

字符串数组：  
字符串数组其中存储的是字符串常量,每个元素都是char型。  
字符串常量是一个以NULL(‘\\0’)结尾的字符数组。  
   
常量（补充）  
常量是一种标识符，它的值在运行期间恒定不变。

Ｃ++中支持4种类型的常量：  
整型、浮点型、字符型和枚举型。

定义常量：常值变量

常用的特殊字符：  
名 称                符 号  
空字符(null)             \\0  
换行(newline)              
换页(formfeed)           \\f  
回车(carriage return)      
退格(backspace)          \\b  
响铃（bell）          \\a  
水平制表(horizontal tab) \\t  
垂直制表(vertical tab)   \\v  
反斜线(backslash)        \\\\  
问号(question mark)      \\?  
单引号(single quote)     \\’  
双引号(double quote)     \\”

3、声明并定义类内的成员函数  
函数:  
概念：是指一系列指令或语句的组合体。  
定义格式：  
<函数返回类型>  <函数名>(<函数参数表>)  
\{  
 函数体；  
\}  
C++中每个函数的定义都是由4个部分组成的，即：函数返回类型、函数名、函数参数表和函数体。

函数名的命名规则：

a.函数名可以是任何一个有效的标识符  
b.函数名是动+名字并有意义  
c.函数名首字母小写，多个单词组合时，第二个单词首字母要大写  
d.函数名不能为C++的关键字  
注：  
(1)、一般地，仅当函数被调用时，系统才会给形参分配内存单元，而调用结束后，形参所占用的内存单元又被释放。  
(2)、函数声明在前，调用在后。  
(3)、调用函数时，实参与形参的个数应相等、类型应一致，且按顺序一一对应传递数据。

class Car  
\{  
        float  price;  
 public:  
        void acceptPrice()  
        \{  
               cout<<“Enter price:”;  
               cin>>price;  
         \}  
          
\};

二、创建对象

1、创建对象的格式：  
<类名>  < 对象名>；  
2、在对象名后面使用“.”操作符访问成员函数  
  
例：Car ford；//创建类Car 的对象ford  
        ford.honk()；//访问成员函数  
注：  
1、类声明不会在声明时保留内存。在创建类的实例时分配内存。类的实例称为对象。  
2、所有对象共享成员函数同样的拷贝，但对成员变量维持个别的拷贝。

数组：test.cpp  
\#include<iostream>  
using namespace std;

class Car  
\{  
    char car\_name;  
    float car\_price;  
\};

int main()  
\{  
    int a1\[3\];  
    float a2\[\]=\{1,3.24,5.89,9.33,2.22\};//定义的同时初始化   
    char ss\[9\]="zhangsan";  
    char sss\[20\]=\{'z','h','a','n','g'\};  
    int a3\[5\]=\{1,34,3\};  
    float c\[5\];  
      
    cout<<"a2\[0\]="<<a2\[0\]<<endl;  
    cout<<"a2="<<a2<<endl;  
    cout<<"a2\[1\]"<<&a2\[1\]<<endl;  
    cout<<"c="<<c<<endl;  
      
    //c=a2;//error  
    /\*error  
    int s\[\];  
    int bb\[2\]=\{2,6,8\};//溢出 \*/  
      
    int i=0;  
    while(i<=9)\{  
  cout<<ss\[i\];  
  i++;  
    \}  
    cout<<endl;  
    system("pause");  
    return 0;  
\}

声明类内的成员变量：sizeof.cpp  
\#include<iostream>  
using namespace std;

/\*class 类名  
\{  
    定义类的成员  
    成员变量  
    成员函数   
\}; \*/

class Car  
\{  
    float car\_price;//成员变量定义的同时不允许付初值  
\};

int main()  
\{  
    int x=10;//局部变量   
    cout<<"x="<<x<<endl;  
    cout<<"int="<<sizeof(x)<<endl;   
    cout<<"float="<<sizeof(float)<<endl;  
    cout<<"double="<<sizeof(double)<<endl;   
    cout<<"bool="<<sizeof(bool)<<endl;  
      
    system("pause");  
    return 0;  
\}

成员函数 ：car.cpp  
\#include<iostream>  
using namespace std;

//定义类  
class Car  
\{  
    float price;  
    public:  
        void acceptprice()  
        \{  
            cout<<"Enter Price :";  
            cin>>price;  
        \}  
        void honk()  
        \{  
            cout<<"Beep Beep";  
        \}  
        void print()  
        \{  
             cout<<price;       
        \}  
\};

int main()  
\{  
    Car ford;  
    ford.acceptprice();  
    system("pause");  
    return 0;  
\}

数组：arry.cpp  
\#include<iostream>  
using namespace std;

int main()  
\{  
    int arry\[\]=\{10,20\};  
    cout<<arry\[1\]<<endl;  
      
      
    const float PI=3.1415926f;  
    //const 数据类型 常量名＝值;   
    float r;  
    float s;  
    s=PI\*r\*s;  
    system("pause");  
    return 0;  
\}

独立实践：  
1.

\#include <iostream>  
using namespace std;

class Employee  
\{  
      char firstname\[16\] ;  
      char lastname \[16\];  
      char dateOfBirth\[12\];  
      char dateOfJoinning\[12\] ;  
      char city \[8\];  
      char phoneNo\[5\];  
      public :  
      void accept ()  
      \{  
        cout <<endl<<"first name :";  
        cin>>firstname ;  
        cout <<endl<<"last name :";  
        cin >>lastname ;  
        cout <<endl<<"dateofbirth :";  
        cin >>dateOfBirth ;  
        cout <<endl<<"city :";  
        cin >>city ;  
        cout <<endl<<"phoneNo:";  
        cin >>phoneNo;  
      //Code to accept employee details   
      \}  
      void display ()  
      \{  
       cout <<endl<<"first name :";  
       cout <<firstname <<endl;  
       cout <<endl <<"last name :";  
       cout <<lastname <<endl;  
       cout <<endl<<"dateOfBirth :";  
       cout <<dateOfBirth <<endl;  
       cout <<endl<<"dateOfJoinning:";  
       cout <<endl<<dateOfJoinning ;  
       cout <<endl<<"city:";  
       cout <<city <<endl;  
       cout <<endl<<"phoneNo:";  
       cout <<phoneNo<<endl;  
      //Code to display employee details  
      \}  
\};

int main ()  
\{  
        Employee employee\_dat;  
        employee\_dat.accept ();  
        employee\_dat.display();  
        system ("pause");  
        return 0;  
\}

3.  
\#include <iostream>  
using namespace std;  
int  main ()  
\{  
     char ch='A';  
     char ch1=66;  
     int  i=60;  
     cout <<ch<<endl<<ch1<<endl<<i;  
     system ("pause");  
     return 0;  
\}

第三课： 封装与抽象

一、访问区分符  
抽象  
是指区别于所有其他种类对象的对象的本质特征  
提供了和用户观点有关的明确的概念边界  
封装  
是隐藏与其本质特征不起作用的对象的所有细节的过程  
防止访问非本质的细节  
也称为信息隐藏或数据隐藏

类背后蕴涵的基本思想是数据抽象和封装。  
数据抽象是一种依赖于接口和实现分离的编程技术。类设计者必须关心类是如何实现的，但使用该类的程序员不必了解这些细节。相反，使用一个类型的程序员仅需了解类型的接口，他们可以抽象地考虑该类型做什么，而不必具体地考虑该类型如何工作。  
封装是一项将低层次的元素组合起来形成新的、高层次实体的技术。函数是封装的一种形式：函数所执行的细节行为被封装在函数本身这个更大的实体中。被封装的元素隐藏了它们的实现细节--可以调用一个函数但无法看到它所执行的语句。同样地，类也是一个封装的实体：它代表若干成员的聚集，大多数设计良好的类类型隐藏了实现该类型的成员。

使用访问区分符的作用：实现抽象和封装

访问区分符用来决定任何其他类或函数可否访问特  
定类的成员变量和函数。

C++支持三种访问区分符：

public  
public访问区分符  
    public 访问区分符号允许其他的函数和对象访问类的成员变量和成员函数。

private

protected  
protected除了类本身的成员函数和友元可以访问保护成员外，该类的派生类的成员也可以访问。

二、静态成员变量和静态成员函数  
      静态变量  
      静态成员

三、友员函数和友员类

第四课 运算符与判定构造

一、运算符

运算符可分为：  
           算术运算符、 赋值运算符、  
           一元运算符、 比较运算符、  
           逻辑运算符

1、算术运算符  
   一般有五种简单的操作：  
   加（+）、减（-）、乘（\*）、除（/）和取模（%）

取模运算符（%）用于计算两整数相除后得到的余数，  
   求模运算只对int型操作数工作。

2、赋值运算符  
   赋值运算符“=”将其右侧的表达式求出结果，赋给其左侧的变量.(即从右向   左赋值)

C++中赋值运算符分为：简单的赋值运算符、复合的赋值运算符。

+ =（加赋值）、- =（减赋值）、\* =（乘赋值）、/ =（除赋值）、% =（取模   赋值）

3、一元运算符  
   一元运算符对一个操作数作运算。一般指自增和自减运算符，如下表所示：

运算符 描述  
   ++        增量运算符使操作数的值增加1  
   --        减量运算符使操作数的值减去1

自增和自减运算符一般有二种使用方式：  
   前缀方式：++x；    --x；  
   后缀方式 ：x++；    x--；  
   前缀方式与后缀方式的区别

4、比较运算符  
   比较运算符又称为关系运算符，用来比较二个值，比较运算符求出值true或   false。

比较运算一般有如下几种：= =、!=、>、<、>=、<=

5、逻辑运算符  
   一般用逻辑运算符来组合二个或多个表达式。

C++提供的逻辑运算符为：AND( && )、OR( || )、NOT( ! )

运算符的优先顺序:  
类型     运算符  
高优先级    \[\]（）  
一元     ！＋＋ - -  
乘除        ＊ ／ ％  
加减     ＋ －  
关系     <     <=      >        >=    
等号 = =     !=  
逻辑 &&  ||  
条件 ？：  
赋值 =  +=  -=  \*=   /=   %=

二、控制语句

算法的基本控制结构有三种：  
顺序结构、选择结构和循环结构，分别由顺序控制语句、选择控制语句和循环控制语句来控制程序的流程。

1、顺序结构：就是按照语句的顺序一条一条地执行。

顺序控制语句一般包括：  
表达式语句、空语句和输入输出语句等。

2、选择控制语句：  
选择控制语句:    \{if语句  
                 if ··· else语句  
                 if···else if 语句  
                 switch语句

if 语句:  
if 语句用于在程序中有条件地执行某一语句序列，它有两种基本语法形式。

(1)if  (< 条件表达式>)   
          < 语句>；

(2)if  (< 条件表达式>)   
    \{

< 语句序列>；  
    \}

控制语句:  
if ··· else 语句  
      语法形式如下：

if ( < 条件表达式>)  
                    \{  
                                < 语句序列1>；  
                     \}    
                     else  \{  
                                < 语句序列 2>；  
                    \}

当条件表达式为true时执行<语句序列 1 >；当<条件表达式>为false时执行<语句序列2>。  
if ··· else if 语句：用于进行多重判断。  
语法形式如下：  
   
                if (< 条件表达式1>)  <语句1>；  
                else if (< 条件表达式2>)  < 语句2>；   
                       .  
                       .  
                       .  
                else if (< 条件表达式n>)  < 语句n >；  
                else < 语句 n+1 >；

C++中规定：  
当多个if ···else语句嵌套时，else总是与最近的一个还没有与else匹配的if匹对。

练习：写一个构造，它根据学生的分数把等级赋给他们。得分在75与100之间的学生给以等级‘Ａ’，得分在50与74之间的学生给以等级‘B’，其余的给以等级‘C’。  
要求用if ···else if ···语句来实现。

3、循环控制语句:

提供重复处理的能力。  
    
C++支持三种格式的循环控制语句：while语句、do…while语句、for 语句。  
(1)while语句  
         
     一般形式：                       
                    while  (< 条件表达式 >)   
                    \{  
                     <语句序列>；  
                     \}

int sum=0；                                              
int i=1； //循环变量初始化  
while(i<=10) //判断条件  
\{                    //循环体  
       sum+=i；  
       i++；//改变循环变量的值  
\}  
cout<<sum<<endl；

(2)do…while 语句

一般形式为：  
   do\{  
        < 语句序列>；  
   \}  
   while  (< 条件表达式 >) ；

int sum=0；    
int i=1；//循环变量初始化  
do\{                      
       sum+=i；//循环体  
       i++；//改变循环变量的值  
  \}   
while(i<=10)； //继续条件  
cout<<sum<<endl；  
区分do…while 语句与while语句的不同。

(3)for 语句  
      for语句通常用于预先知道循环次数的情况。

其一般表示形式为：  
for (< 初始化表达式>;<测试表达式>;<改变表达式>)   
\{  
         <语句>；  
\}

初始化表达式  
只执行一次，在控制第一次转入此循环时，它给循环变量一个初始值。

测试表达式  
每当执行此条件时，控制转向循环的头。如果此条件的求值为true，执行此循环，否则控制转向循环体后的语句。

增量/减量表达式  
控制返回到循环的头时执行。

int sum=0;    
for(int i=1; i<=10; i++)  
\{                        
       sum+=i;    //循环体  
\}  
cout<<sum<<endl;

4--1.接受并显示10个顾客的未付款总数，未付总数应以递升次序排列：

\#include <iostream>  
using namespace std;  
class Customers  
\{  
    float amounts\[10\];   
  public:

void sortData()\{  
   int ctr; //定义for循环的控制变量   
   for( ctr=0; ctr < 10; ctr ++)//接受10个顾客的未付款总额   
   \{  
     cout << "Enter the amount : ";  
  cin >> amounts\[ctr\];  
   \}  
     
     
      int counter = 0;//定义while循环的控制变量并进行初始化   
   while (counter <9 )//实现排序   
   \{  
     float temp;//排序辅助变量   
  if (amounts\[counter\] > amounts\[counter + 1\])  
  \{  
    temp = amounts\[counter\];  
    amounts\[counter\] = amounts\[counter+1\];  
    amounts\[counter + 1\]=temp;  
    counter = 0;  
    continue;  
  \}  
  counter++;//counter = counter +1;  
   \}  
 \}

void display()  
 \{  
   for (int counter =0; counter<10 ; counter++)  
   \{  
     cout << "Element "<< counter <<":  "<<amounts\[counter\] <<endl;  
   \}  
 \}  
\};

int main()  
\{  
  Customers C1;  
  C1.sortData();  
  C1.display();  
  system("pause");  
  return 0;  
\}

4--2.降序排列：   
\#include<iostream>  
using namespace std;  
class Po  
\{  
      float ip\[10\];  
      public:  
             void sortdata()  
             \{  
                  for (int i=0;i<10;i++)  
                  \{  
                      cout <<"enter the count :"<<endl;  
                      cin>>ip\[i\];  
                  \}  
                      int tem=0;  
                      while (tem<10)  
                      \{  
                        float te;  
                        if (ip\[tem\]<ip\[tem+1\])  
                  \{  
                           te = ip\[tem\];  
                           ip\[tem\] =ip\[tem+1\];  
                           ip\[tem + 1\]=te;  
                           tem = 0;  
                           continue;  
                   \}  
                   tem++;  
                     \}  
             \}  
               
             void display()  
             \{  
               for (int   tem=0;  tem<10 ;  tem++)  
               \{  
                 cout << "Element "<<tem <<":  "<<ip\[tem\]<<endl;  
               \}  
             \}     
\};

int main ()  
\{  
    Po p;  
    p.sortdata();  
    p.display();  
    system("pause");  
\}

4--3.输入十个数，并让其自动按降序排列：  
\#include <iostream>  
using namespace std;  
class CalSalary  
\{  
    float amounts\[10\];  
    public:  
    void sortData()  
    \{  
     int counter=0;  
     amounts\[0\]=200.5;  
     amounts\[1\]=323;  
     amounts\[2\]=0;  
     amounts\[3\]=100.7;  
     amounts\[4\]=314;  
     amounts\[5\]=523;  
     amounts\[6\]=256;  
     amounts\[7\]=10.90;  
     amounts\[8\]=553.90;  
     amounts\[9\]=0;  
     while(counter < 9)  
     \{  
             float temp;  
           if(amounts\[counter\] < amounts\[counter + 1\])  
          \{  
           temp = amounts\[counter\];  
           amounts\[counter\] = amounts\[counter+1\];  
           amounts\[counter + 1\] = temp;  
           counter = 0;//双层循环 ，每次发生交换时从头开始   
           continue;//强制终止  
                          \}  
                          counter++;  
             \}  
   \}  
   void display()  
   \{  
    for(int ctr=0; amounts\[ctr\]!='\\0';ctr++)  
      cout<< " "<<amounts\[ctr\];  
   \}

\};  
int main()  
\{  
    CalSalary L1;  
    L1.sortData();  
    L1.display();  
    system("pause");  
\}

4--4.打印乘法九九表：  
for(;;)\{  
       for(;;)\{

\}  
\}

方法1：  
\#include <stdio.h>

main()   
\{   
int i, j;   
for( i = 1; i <= 9; i ++ )   
\{   
for( j = 1; j <= i; j ++ )   
\{   
printf("%d\*%d=%d\\t", i, j, i\*j );   
\}   
printf("");   
\}   
getchar();   
\}

方法二：  
\#include <iostream>   
using namespace std;  
class Pv  
\{   
int i,j;   
public:  
 void display()  
 \{  
  for(i=1;i<=9;i++)   
 \{  
               ( cout<<endl; )  
  for(j=1;j<=i;j++)   
 \{  
  cout<<j<<"\*"<<i<<"="<<j\*i<<" "(endl);   
 \}   
 cout<<endl;   
\}  
\}  
\};

int main()   
\{  
 Pv p;  
 p.display();  
 system("pause");  
    return 0;   
\}

方法三：  
\#include<iostream>   
using namespace std;

int main()   
\{   
int i;   
int j;   
int sum;   
for(i=1;i<=9;i++)\{//一个for语句的嵌套   
for(j=1;j<=i;j++)\{   
sum=i\*j;   
cout<<j<<"\*"<<i<<"="<<sum<<" ";   
\}   
cout<<endl;   
\}   
system("pause");  
\}

方法四：do...while

\#include<iostream>   
using namespace std;

int main()   
\{   
int i=1;//定义i的初识值   
int j=1;//定义j的初识值   
int sum;//定义一个变量sum   
do\{   
j=1; //定义了j为1这样没次j都从1开始   
do\{   
sum=i\*j; //把每次i\*j的值赋值给sum   
cout<<j<<"\*"<<i<<"="<<sum<<"\\t";//输出   
j++; //每次j都+1   
\}while(j<=i); //当j大于i的时候退出循环   
i++;//每次这里i+1   
cout<<endl;//空一行   
\}while(i<=9);//当i大于9的时候退出   
cout<<endl;  
system("pause");  
return 0;  
\}

4、转移语句  
跳转语句包括：break、continue语句

(1)break 语句  
break语句用于强制退出当前的循环语句(do、while、和 for) 以及switch语句的执行，接着执行循环语句后面的语句。

(2)continue语句  
continue语句也用于循环语句，它类似于break，但它不是结束循环，而是结束循环语句的当前一次循环，接着执行下一次循环。

问题陈述4.D.1  
编写一个程序：它将把所接受的串倒过来并把它拷贝到另一个串。

问题陈述4.D.2  
编写一个程序：它接受并显示10个顾客的未付款总数。未付款总数应以递升次序显示。

4--5.1、问题陈述4.P.1  
编写一个程序：它接受来自用户10个职工的工资，并以递降次序显示所有职工的工资。如果用户键入的是零，此程序应显示消息“The amount should be greater than zero”并再一次接受值。

4--6.2、猴子吃桃  
猴子第一天摘了若干桃子，它吃了一半并多一个。第二天它又吃了剩下的一半并多一个，第三天吃了剩下的一半并多一个……第10天吃完后还剩一个桃子。问第一天猴子摘了多少个桃子？

\#include<iostream>  
using namespace std;  
   
int main()  
\{  
   int day;  
   int sum=1;  
   for(day=10;day>=1;day--)  
   \{  
      sum=(sum+1)\*2;   
   \}  
    cout<<"猴子第一天摘："<<sum<<endl;  
    system("pause");  
    return 0;  
\}

4--7.3、1/1+1/2+1/3+……+1/100=?编程实现。

三、变量的作用域

作用域：又称为作用范围。在程序中出现的各个变量都有他们自己的作用域。变        量的作用域指出它可访问的地方。

C++有三种类型的作用域：文件作用域、局部作用域、类作用域。

文件作用域(全局作用域)：指最外层的作用域，所有函数类之外的作用域。

局部作用域：一般是指函数的花括号内，或者是for 、while、if控制结构内的范围。

类作用域：类域类似于局部作用域，一个类定义就是一个类。

不同作用域中的变量可以重名。

全局变量：在函数、类外面定义的变量；具有文件作用域的变量。  
   1、全局变量存放在全局数据区。  
   2、作用域从声明点开始,一直延续到原文件结束。（例子）

局部变量：在函数内部定义的变量或块中声明的变量；具有局部作用域的变量。  
   1、局部变量在栈区分配内存。  
   2、局部变量只在定义它的函数内部或是块内部可见。当函数调用结束时，局      部变量随之消失。

C++程序的内存格局：  
全局数据区:   全局变量，静态数据，常量  
（gobal area)

代码区:       所有函数代码  
（code area)

栈区:         局部变量，函数的参数、返回数据、返回地址  
（stack area)

堆区:         动态数据  
（data area)

独立实践：  
创建一个菜单驱动，它接受十个员工的工资并显示以下信息：  
最大工资  
最小工资  
工资平均值  
按升序排列  
按降序排列

方法一：  
\#include <iostream>  
using namespace std;

class Employee   
\{  
    float menu\[10\];  
    public:  
        void display\_details() //接受十个员工的工资；  
        \{  
            for (int i=1;i<=10;i++)  
            \{  
                cout<<"menu: "<<i<<endl;  
                cin >>menu\[i\];  
            \}  
        \}  
        void sort()  
        \{  
            for (int i=0;i<=10;i++)  
            \{  
                for (int j=0;j<=10-i;j++)  
                \{  
                    float temp;  
                    if (menu\[j\]>menu\[j+1\])  
                  \{  
                    temp=menu\[j\];  
                    menu\[j\]=menu\[j+1\];  
                    menu\[j+1\]=temp;  
                  \}  
                \}  
            \}  
        \}  
        void display\_max()  
        \{  
            sort();  
            cout <<"the employee of max:"<<menu\[10\]<<endl;  
             
        \}  
        void display\_min()  
        \{  
            sort();  
            cout <<"the employee of min:"<<menu\[1\]<<endl;  
              
       \}  
       void display\_avg()  
       \{  
           float sum=0;  
           for (int i=0;i<=10;i++)  
           \{  
           sum+=menu\[i\];  
           \}  
           float average;  
           average = sum/10;  
           cout<<"the employee of average:"<<average <<endl;  
       \}  
       void count()  
       \{  
   int n=0;  
            for(int i=0;i<=10;i++)  
            \{  
       
               if(menu\[i\]>=1000)  
               n++;  
            \}  
            cout <<"the employee of count:"<<n<<endl;  
       \}  
       void displayASC()  
       \{  
            sort();  
            for (int i=0;i<=10;i++)  
            \{  
            cout<<"the employee of next:"<<menu\[i\]<<endl;  
            \}  
       \}  
       void displayDESC()  
       \{  
            sort();  
            for (int i=10;i>=0;i--)  
          \{  
            cout<<"the emplayee of next:"<<menu\[i\]<<endl;  
          \}  
       \}  
\};  
         
int main()  
\{  
    Employee emp;  
    emp.display\_details();  
      
    int e=1;  
    while (e!=6)  
    \{  
          cout <<"1.the employee of max: "<<endl;  
          cout <<"2.the employee of min: "<<endl;  
          cout <<"3.the employee of avg: "<<endl;  
          cout <<"4.the employee of asc: "<<endl;  
          cout <<"5.the employee of desc: "<<endl;  
          cout <<"6.exit"<<endl;  
          cin>>e;  
          switch(e)  
          \{  
             case 1:  
            emp. display\_max();  
             break;  
             case 2:  
              emp.display\_min();  
             break;  
             case 3:  
              emp.display\_avg();  
             break;  
             case 4:  
            emp. displayASC();  
             break;  
              case 5:  
            emp. displayDESC();  
             break;  
             case 6:  
             break;  
             default:  
                     cout<<"please the employee of data is error"<<endl;  
              
    \}  
  \}  
\}

方法二：

\#include<iostream>  
using namespace std;

class Employee  
\{  
    float dalary\[10\];  
    float temp,average,sum;  
    int n;  
public:  
    void accept()  
    \{  
        for(int i=0;i<10;i++)  
        \{  
                cout<<"请输入第"<<i+1<<"个员工工资：";  
                cin>>dalary\[i\];      
        \}      
     \}     
      
    void sort()  
    \{  
        for(int i=0;i<10;i++)  
        \{  
            for(int j=0;j<10-i;j++)  
            \{  
                 if(dalary\[j\]>dalary\[j+1\])  
                  \{  
                     temp=dalary\[j\];  
                      dalary\[j\]=dalary\[j+1\];  
                       dalary\[j+1\]=temp;   
                   \}      
            \}      
        \}      
    \}  
    void max()  
    \{  
     sort();  
      cout<<"最高收入是："<<dalary\[9\]<<endl;      
    \}  
    void min()  
    \{  
     sort();  
      cout<<"最低收入是："<<dalary\[0\]<<endl;      
    \}  
    void avg()  
    \{  
     sum=0;  
      for(int i=0;i<10;i++)  
      \{  
           sum+=dalary\[i\];  
       \}   
        average=sum/10;  
        cout<<"平均收入是："<<average<<endl;     
    \}  
      
    void count()  
    \{  
     n=0;  
      for(int i=0;i<10;i++)   
      \{  
          if(dalary\[i\]>=1000)  
            n++;   
       
       \}    
       cout<<"共有"<<n<<"个员工收入超过1000元"<<endl;   
    \}  
    void displayAsc()  
    \{  
     sort();  
      for(int i=0;i<10;i++)  
      \{  
         cout<<"请输入第"<<i+1<<"个员工工资："<<dalary\[i\]<<endl;    
       \}      
    \}  
    void displayDesc()  
    \{  
     sort();  
      for(int i=9;i>=0;i--)  
      \{  
         cout<<"请输入第"<<i+1<<"个员工工资："<<dalary\[i\]<<endl;    
       \}      
    \}  
\};

int main()  
\{  
 Employee obj;  
 obj.accept();  
  int reply=1;  
  while(reply!=7)  
  \{  
     cout<<"------------------工资管理-------------------"<<endl;  
      cout<<"1、显示最高工资。"<<endl;   
     cout<<"2、显示最低工资。"<<endl;  
      cout<<"3、显示平均工资。"<<endl;  
       cout<<"4、显示工资超过1000元的员工人数。"<<endl;  
      cout<<"5、以递升顺序显示员工工资。"<<endl;  
      cout<<"6、以递降顺序显示员工工资。"<<endl;  
   cout<<"7、退出。";  
   cin>>reply;  
      switch(reply)  
      \{  
         case 1:  
              obj.max();  
               break;  
            case 2:  
                obj.min();  
                break;  
             case 3:  
                 obj.avg();  
                 break;  
             case 4:  
                 obj.count();  
                 break;  
             case 5:  
            obj.displayAsc();  
            break;  
        case 6:  
            obj.displayDesc();  
            break;  
        case 7:  
           break;  
       default:  
        cout<<"请输入1-7之间的选择。"<<endl;  
       \}  
   \}  
        
\}

方法三：

\#include<iostream>  
using namespace std;

class Employee  
\{  
    float dalary\[10\];  
    float temp,average,sum;  
    int n;  
public:  
    void accept();  
    void sort();  
    void max();  
    void min();  
    void avg();  
    void count();  
    void displayAsc();  
    void displayDesc();  
\};  
  void Employee::accept()   
    \{  
        for(int i=0;i<10;i++)  
        \{  
                cout<<"请输入第"<<i+1<<"个员工工资：";  
                cin>>dalary\[i\];      
        \}      
     \}  
     void Employee::sort()    
     \{  
        for(int i=0;i<10;i++)  
        \{  
            for(int j=0;j<10-i;j++)  
            \{  
                 if(dalary\[j\]>dalary\[j+1\])  
                  \{  
                     temp=dalary\[j\];  
                      dalary\[j\]=dalary\[j+1\];  
                       dalary\[j+1\]=temp;   
                   \}      
            \}      
        \}      
    \}  
      void Employee::max()  
      \{  
     sort();  
      cout<<"最高收入是："<<dalary\[9\]<<endl;      
    \}  
      void Employee::min()  
    \{  
     sort();  
      cout<<"最低收入是："<<dalary\[0\]<<endl;      
    \}  
       void Employee::avg()  
    \{  
     sum=0;  
      for(int i=0;i<10;i++)  
      \{  
           sum+=dalary\[i\];  
       \}   
        average=sum/10;  
        cout<<"平均收入是："<<average<<endl;     
    \}  
      void Employee::count()  
    \{  
     n=0;  
      for(int i=0;i<10;i++)   
      \{  
          if(dalary\[i\]>=1000)  
            n++;   
       
       \}    
       cout<<"共有"<<n<<"各员工收入超过1000元"<<endl;   
    \}  
    void Employee::displayAsc()  
    \{  
     sort();  
      for(int i=0;i<10;i++)  
      \{  
         cout<<"请输入第"<<i+1<<"个员工工资："<<dalary\[i\]<<endl;    
       \}      
    \}  
    void Employee::displayDesc()  
    \{  
     sort();  
      for(int i=9;i>=0;i--)  
      \{  
         cout<<"请输入第"<<i+1<<"个员工工资："<<dalary\[i\]<<endl;    
       \}      
    \}  
          
int main()  
\{  
 Employee obj;  
 obj.accept();  
  int reply=1;  
  while(reply!=7)  
  \{  
     cout<<"------------------工资管理-------------------"<<endl;  
      cout<<"1、显示最高工资。"<<endl;   
     cout<<"2、显示最低工资。"<<endl;  
      cout<<"3、显示平均工资。"<<endl;  
       cout<<"4、显示工资超过1000元的员工人数。"<<endl;  
      cout<<"5、以递升顺序显示员工工资。"<<endl;  
      cout<<"6、以递降顺序显示员工工资。"<<endl;  
   cout<<"7、退出。";  
   cin>>reply;  
      switch(reply)  
      \{  
         case 1:  
              obj.max();  
               break;  
            case 2:  
                obj.min();  
                break;  
             case 3:  
                 obj.avg();  
                 break;  
             case 4:  
                 obj.count();  
                 break;  
             case 5:  
            obj.displayAsc();  
            break;  
        case 6:  
            obj.displayDesc();  
            break;  
        case 7:  
           break;  
       default:  
        cout<<"请输入1-7之间的选择。"<<endl;  
       \}  
   \}  
        
\}

第五课  构造函数和析构函数

一、构造函数

1、构造函数的作用：  
只要类的对象一建立，构造函数马上被自动唤起，对成员变量初始化。   
C++规定:每个类必须有一个构造函数，没有构造函数就不能创建对象。

2、声明构造函数要注意：  
构造函数的名字必须与类名完全相同。  
不可返回任何值，甚至不可返回void 类型。  
构造函数可以有参数 (带参数的构造函数) ，可以重载。

3、缺省构造函数  
万一类没有声明构造函数，编译器会自动创建一个缺省的构造函数，这个缺省的构造函数是个无参构造函数。只要类已经定义了构造函数,编译器就不再提供缺省的构造函数。

４、成员方式初始化  
可以用一个对象来初始化另一个被创建的同类对象，这种方式称为成员方式初始化。

例如：        Calculator obj1;          
              Calculator obj2=obj1;  
这种情况下就是成员方式初始化.调用的拷贝构造函数。

二、析构函数

1、为什么需要析构函数：  
用它在撤消对象时对它们“去初始化”。  
用它在对象离开作用域时清除数据成员所占有的内存空间。

2、声明析构函数要注意：  
必须有与其类一样的名，前面带有~  (否定号) (例~Calculator())。  
没有返回类型、没有参数，不可被重载。

3、析构函数在对象离开作用域时自动地被调用 ，也可在需要时显式地被调用

例子：(P5.6)  
作用域分解运算符(::)：用来在类定义之外定义成员函数，以便使类定义更好读

三、对象的生命周期  
１、对象的分类  
全局对象：具有全局作用域的对象。  
局部对象：具有函数作用域或块作用域的对象。  
类的成员对象：具有类作用域的对象。  
\#include <iostream>  
using namespace std;

class A  
\{  
public:  
    A()  
    \{  
        cout<<"class A's constructor invoked"<<endl;  
    \}  
    ~A()  
    \{  
        cout<<"class A's destructor invoked"<<endl;  
    \}  
\};  
class B  
\{  
public:  
    B()  
    \{  
        cout<<"class B's constructor invoked"<<endl;  
    \}  
    ~B()  
    \{  
        cout<<"class B's destructor invoked"<<endl;  
    \}  
\};  
A a;//全局变量 ，全局性的事物一般情况不要使用

int main()  
\{  
    cout<<"main()开始"<<endl;  
    B b;//局部变量   
    cout<<"main()结束"<<endl;   
    system("pause");  
    return 0;  
\}

２、如何调用构造函数和析构函数

全局对象的构造函数在main()执行开始前执行，析构函数是在程序结束时调用的。

具有函数作用域的对象的构造函数在main()开始执行时执行，析构函数是在main()执行结束时调用的。

具有块作用域的对象的构造函数在其内部的块执行开始之后执行的，析构函数是在内部块执行结束时调用的。  
  
当有多个局部对象时以声明的顺序构造。  
  
成员对象以其在类中声明的顺序构造。

(析构函数以调用构造函数相反的次序被调用)  
(例1：课本)

指针与引用

一、指针的定义及初始化

1、指针以及指针变量

指针是一种数据类型。  
   指针变量是指具有指针类型的变量；指针变量是专门存放地址的变量。  
   ?   变量的内存地址  
   ?   进程的地址空间  
   指针指向对象，指针提供对其所指对象的间接访问的

2、指针变量的声明格式

数据类型  \* 指针变量名；

指针变量：  
\#include <iostream>  
using namespace std;  
class Course  
\{  
      public:  
             void accept()  
             \{   
                   int m=10;  
                   int \*n;  
                   n=&m;  
                   cout<<"Enter the number is" <<m;  
             \}  
\};

int main()  
\{  
    Course c;  
    c.accept();  
    system("pause");  
    return 0;  
\}

3、指针的初始化  
eg:  
                    int     \* ptr ;  
                    int     age=20;  
      ptr=& age;  
注意：  
1)、每一个指针变量都有一个相应的所有的数据类型，该类型用以说明这个指针变量所指向的地址中存放数据的类型。  
2)、\*有2中作用，在声明中，\*是指针类型的标识符。\*不是变量名的一部分。  
3)、变量名命名规则与一般的变量名一样。  
4)、要对定义好的指针进行初始化。

二、指针运算

1、取值运算与取地址运算

\* 是取值运算符。(\* 的第二种作用)  
形式：\* 操作数；  
作用：取出指针变量所指向存储空间保存得值。

& 是取址运算符。  
形式：& 操作数；  
作用：取出操作数的存储空间地址。

2、指针变量加减一个整数（n）  
作用：是指针向上或向下移动n个地址。  
eg：  
    int \* ptr ;  
    int  a\[5\]=\{1,2,3,4,5\};  
    ptr=a;//a代表数组A的首地址a\[0\]；ptr代表指向数组a的值的地址  
   cout<<“数组a中的元素”<<\* ptr<<endl;  
   ptr=ptr+1;  
   cout<<“数组a中的元素”<<\* ptr<<endl;

字符串常量、字符数组、字符指针不同点：

字符串常量和字符数组  
1)、由引号标识，但不是用来初始化数组的字符串，是字符串常量。  
eg：  
    cout<<“hello”;  //此处“hello”是字符串常量  
    char c\[ \]=“hello”;//此处“hello”不是字符串常量

2)、字符串常量一定存放在内存的全局数据区。   
    字符数组根据它的作用域决定存放在哪里。

3)、对字符串常量和字符数组名的比较  
      都是对两个地址的比较。  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
|if(“hello”==“hello”)     |        \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
|      cout<<“equal”<<endl; |        |    char c1\[ \]=“hello”;    |  
|                             |        |    char c2\[ \]=“hello”;    |  
|                             |        |      if( c1==c2)            |  
|                             |        |      cout<<“equal”;       |  
|\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_|        ——…————————————  
            \\                        /       
\_\_\_\_\_\_\_\_\_\_\_\_\_\\\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_    /        
|用strcmp()真正从字面上比较     |/         
|\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_|

例子：  
字符比较：  
\#include<iostream>  
using namespace std;

int main()  
\{      
    //字符串比较   
    char c1\[6\]="hello";  
    char c2\[\]="hello";  
    //if(strcmp(c1,c2)==0)  
    //if(c1==c2)//对数组的地址进行比较 ==是用于测试对象的地址   
    //if("hello"=="helle")  
    if(strcmp("hello","hello")==0)  
    cout<<"They equal!"<<endl;  
    else   
    cout<<"They don't equal!"<<endl;

system("pause");  
    return 0;  
\}

字符指针和字符数组

字符指针是变量，而字符数组名是常量。  
char c\[ \]=“good”; //right  
char d\[5\];  
d=“good”;  //wrong  
strcpy(d , “good”); //right  
char \* p;   
p=“good”; //right

\#include <iostream>   
using namespace std;  
int main()  
   \{  
 char buffer\[10\]="abc";  
 char \*pc;  
 pc="hello";//pc指针指向hello   
 cout<<pc<<endl;//pc的地址，pc指向字符串，hello是字符串的首地址          ，打印hello   
   
 pc++;//+1的操作   
 cout<<pc<<endl;//打印ello   
 cout<<\*pc<<endl;//解引用操作符；e  //打印当前指针所指的值e   
   
 pc=buffer;  
 cout<<pc<<endl;  
 system("pause");  
 return 0;  
   \}

三、指针的应用(字符指针)

四、动态数据（内存中的堆）

存在两种类型的变量  
一种变量是：在程序编译时分配内存空间  
一种变量是：在程序运行时才在内存中创建

堆内存也称为动态内存。  
1、堆允许程序在运行时（而不是在编译时），申请某个大小的内存空间。  
2、如果分配了堆内存，就有责任回收它，否则它会在整个程序运行期间一直存在，存在内存泄漏的危险。   
1)、用new运算符来分配对内存  
语法格式： <指针变量>= new  <数据类型>；  
2)、用delete运算符来释放堆内存  
语法格式：delete   <指针变量>;

例：char var；  
例：char \*ptr = new  char；  
        ···  
    delete ptr；

car a=new c;  
car a;  
a=new c;

函数的参数传递

包括：按值传递、按引用(别名)传递、按地址传递。  
指针与引用  
1、按值传递  
当参数按值传递时，形参是实参的拷贝，被调函数内部对形参值的修改不会影响到实参的值。  
例如：声明：void swap(int a,int b);  
      被调用：swap(aa,bb);

2、按引用传递  
当参数按引用传递时，传递的是原来的变量或对象引用名,而不是在函数作用域内建立变量或对象的拷贝。被调函数内部对形参的修改就是对实参的修改。  
例如：声明：void swap(int &a,int &b);       
      被调用：swap(aa,bb);

引用

一、引用的概念

引用是个别名，  
可用引用(别名)运算符&给一个变量两个名字。

声明格式：<类型>  &<引用名>=<变量名>;

例如：  
        int  num=5;  
        int &anum=num;

二、注意：

1、引用在声明时必须被初始化。  
2、引用变量已定义指称某个变量之后，就不可再指称另一个变量。  
(引用变量只能是一个变量的别名。)  
 但一个变量可以有不止一个引用。  
3、引用仅仅是一个别名，它不占存储空间。  
4、数组名不能被引用。

3、按地址传递  
所谓地址传递，是指在函数定义时将形参说明成指针，这样调用函数时就需要指定地址值形式的实参。  
实现机制：是让形参的指针直接指向实参，在被调用的函数中可以通过改变形参指针所指的实参变量值来间接改变实参值。  
特点：通过改变形参所指向的变量来影响实参。

例如：声明：void swap(int \*p1,int \*p2);  
           被调用：swap(&aa,&bb);  
int a =10;       10声明一个变量并初始化  
int \*p;        \*p声明指针变量,存放地址  
p=&a;          &a是取p所在的变量的地址。把10的地址赋给9；给指针变量赋值  
               让p指向a  
cout <<p;      p打印p中所存在的值     
cout<< \*p;     \*p代表p所在的变量的位置的值，p所存放的值的指向  
对\*p的操作 就是对a的操作  
\*操作符是（解引用）

|-〉a  10  
  \\地址  p

int a=10;  
int \*9;  
\*p=15 是指向内存地址的值

转载于:https://my.oschina.net/alphajay/blog/28713