Visual C++与面向对象程序设计教程

第 3 章 基本数据类型计算机教学实验中心计算机教学实验中心

西安交通大学西安交通大学

教学目标

C++ 语言的基本数据类型 整型、实型

C++ 的构造类型 数组

C++ 语言的数据 ( 形式 ) 常数、变量

学习要求

掌握常量与变量、整型数与实型数的概念。 掌握字符型数据与字符串型数据的概念以及二者的区别。 掌握各种类型的变量说明及其初始化。 掌握各种数组类型的使用方法 进一步熟悉 C++ 程序的编辑、编译、连接、运行的过程。

授 课 内 容

3.1 数据类型

3.2 常量 3.3 变量

3.4 数组 3.5 字符型数组和字符串处理库函数 调试技术 程序设计举例

3.1 、数据类型

计算机能够做许多事情。但是，归根到底计算机只能处理数据。 大千世界丰富多彩。为表现不同性质的事物，要用不同的数据类型。 在计算机中，为方便数据处理，采用两种基本形式存放数据。

数据

是对认识的事实性记载 是用来表示客观事物的符号 是指能够由计算机处理的数字、字母、符号、声音、图象、影视信息等。 是程序的必要组成部分和程序处理的对象。

数的表示 在计算机中为了区别不同的数，使用了不同的表示 方法。包括：

整数的表示 实数的表示 字符数据的表示 数组的表示

数据类型 计算机只能存放二进制数据。不同类型的事物如何区分和描述？由此产生数据类型。 不同类型的数据占据不同长度的存储单元。 不同类型的数据对应不同的值域范围。 不同类型的数据对应不同的操作（运算）及规则。 数据类型越丰富，求解能力越强大。

图 3.1 C++ 数据类型的分类

3.2 、基本数据类型 C 语言的基本数据类型：

数据类型 类型说明浮 占用字节 字符型 char 1 个 短整数 short 2 个 整型 int 4 个 浮点型 float 4 个 双精度型 double 8 个

数据在计算机中的存放

数据在计算机中采用二进制存放；一个字节 8 个二进制位，示意图如下：

数的表示范围： -2^7~2^7-1(-128~127)

显然，一个字节表示数的范围是有限的。要表示更大范围内的数，就要使用多个字节。

7 0

整数的存储格式 字符型

短整型　　短整数表示范围为： -2^15~2^15-1(-32768~32767)

长整型

长整数表示范围为： -2^31~2^31-1

7 0

15 8 7 0

31 24 23 16 15 8 7 0

实数的表示 实数也称为浮点数，用于表示小数；有两种表示形式：

十进制形式：ｘｘｘｘｘ . ｘｘｘｘ 指数形式：ｘｘｘ . Ｅｘｘ

一般浮点数的可以达到 7 位有效数字。例如 1234.567 。双精度浮点数的有效位数可以达到 15~16 位。

尾数部分 指数部分

31 24 23 16 15 8 7 0

常数和变量 变化的量称变量； 不变化的量称常量； 常量和变量是计算机语言中数据的两种基本形式。

3.2 常量 整型常量

0, 1, 2, 637, 32767, 32768, … 0L, 1L, 2L, 637L, 32767L, 32768L, …

实型常量 0.0, 1.0, 2.68, 3.141593, 637.312, … 0.0E0, 6.226e4, 6.226E4, 1.267E20, …

字符常量 'a', 'A', '1', ' ', '+', … '\n'( 换行 ), '\r'( 回车 ), '\t'( 横向跳格 ), '\''( 单引号 ), …

字符串常量 . "Visual C++", "12.34", "This is a string.\n", …

常数 符号常数 整型常数 实型常数 字符型常数 8 进制常数 16 进制常数

（ 1 ）符号常数 用 #define 定义的常数；类似变量，但不是变量。 例如： #define PI 3.1415926

#define MAXNUM 10000 可以出现在表达式中； f1= r * r * PI; 但是不能作左值 , 下列用法是错误的：　　　　 PI = PI*PI ; 用 const 定义的常数　　　　 const double pi=3.1415926;

（２）整、实型常数 整型常数的表示范围是 :－ 32768~32767 例如： 128 ， 256 实型常数的表示范围是 :10-38~1038

例如： 2.7198 , 1.034e14

（ 3 ）、字符型常数 由单引号括起来的单个字符。 例如，‘ A’ ‘， b’ ‘， C’

（ 4 ）、 8 进制常数 8 进制常数是以 0 打头的 8 进制数组成。 合法的 8 进制数： 072 ， 0777 ， 0100

非法的 8 进制数： 0800 ， 7600 ， 0776

（ 5 ）、 16 进制常数 16 进制常数是以 0x 打头的 16 进制数组成。 合法的 16 进制常数： 0x10001 ， 0xABC ， 0xffff

非法的 16 进制常数： FFFF ， aaaa ， 0xgggg

文字数据表示 文字数据有两种：

单个字符， 例如，‘ A’ ‘、 \0’ ‘ ‘ 、 等 字符串，例如，“ This is a string .”

计算机中的文字使用 ASCII 字符，总共有 128 个： 10 个阿拉伯数字 52 个英文字母 32 控制字符（非显示字符） 34 个特殊字符

ASCII 码对应的字符： ‘A’ 的值 65 、‘ a’ 的值 97 （差是 32 ） ‘0’ 的值 48 回车键的值 13 、 ESC 键的值 27 问号‘？’的值 63 、‘ *’ 的值 42

例 3.1 VC0301.CPP

将大写字母转换为小写字母。 转换公式： ch = ch - ‘A’+‘a’ 算法分析：

输入一个字符，判别是否是字母；是字母将其转换为小写否则，跳过

按转换公式进行转换 输出转换结果值

转换子函数 lower （）程序 //Example3.1: 将大写字母转换为小写字母 */int lower(int ch) { if(ch>='A' && ch<='Z') ch = ch-'A'+'a'; return ch; }

VC0301.CPP 主函数#include <iostream.h>main(){ char s[100] = "Hello, C!"; int i= 0, c; while(s[i]!=0) { c = lower(s[i]); s[i]=c; i = i+1; } cout<<s;}

数据基本形式 在实际数据处理过程中，有些数据经常变化（大批量），而有些数据不变化（个别）。 变化的量称变量，不变化的量称常量。常量和变量是计算机语言中数据的两种基本形式。 常量和变量的运算规则是有区别的。

3.3 变量 Ｃ ++ 的数据变量说明语句的格式为 :

< 类型说明符 > < 变量名 1> ; 4 种Ｃ ++ 整数数据类型的说明符分别为 :

char c1, c2; // 说明了 2 个字符型变量 int i, j, k; // 说明了 3 个整型变量 long len; // 说明了 1 个长整型变量

说明浮点类型和双精度类型的变量 float average, sum; // 说明了两个浮点类型的变量 double distance, weight; // 说明了两个双精度类型的变量

1 、变量 变量定义 变量命名规则 变量使用规则 变量初始化 变量引用 类型修饰符

（ 1 ）变量定义 用基本数据类型描述符说明的对象是定义的变量。 例如：

int i,j,k,*p;

float eps,f0,f1[5];

char c0,c1,c2[100];

double array[10][10];

(2) 变量 (标识符 )命名命名规则： （ 1 ）变量名只能由字母、数字或下划线组成； （ 2 ）变量名的第一个字符必须是字母或下划线； （ 3 ）变量名长度不超过 32 个字符（ TC ）；

（ 4 ）不要用保留字定义变量名（有 32 个保留字）。合法变量名： a 、 b1 、 _area 、 employee_name

不合法变量名 : 1-name 、 max one 、 float 、 *account

（ 3 ）变量使用规则 先定义，后使用； 例如： int a ， b ， c ；

a=1 ； b=2 ；

c= a+b ；

下列用法是错误的： b=a+c ；

printf “（ max=%d\n”,max); 不能用保留字作变量名 例如： sin=1.0;

printf= “Print Formatting.”;

（ 4 ）变量初始化 变量初始化就是给变量赋初值；有两种形式：

先定义，再赋初值； 例如： int sum ， fac ；

sum=0 ； fac=1 ；

定义时赋值 例如： char c=‘A’;

int count = 0;

(5) 变量引用 作为“左值”，出现在赋值语句左边； 例如： i=i+1 ； sum=sum+i ； 出现在表达式中； 例如： x1 = （ x0 + x / x0 ） / 2 ； 作为函数的参数； 例如： printf “（ max=%d\n” ， max （ a ， b ））；

作为数组的下标表达式； 例如： c[i][j]=a[i][k]*a[k][j];

(6) 类型修饰符 在基本数据类型前加类型修饰符，可以改变数据表示的范围。常用的有：

unsigned —— 无符号 long —— 长型 short —— 短型

例如： unsigned char 表示范围变为 0~255

unsigned int 表示范围变为 0~65535

例 3.2 VC0301.CPP

用牛顿迭代法求平方根。迭代公式为：

迭代结束的条件为： 算法分析：

定义两个变量 X0 、 X1

X1 取初值 1.0

循环执行：迭代公式 判别 X0 和 X1 的相对误差 eps若大于 eps ，继续执行否则，得到结果的根；结束循环。

2)/(

1nn

nxax

x

1

1

n

nn

xxx

程序逻辑功能框图

输入成绩 X

X0 = X1X1 = ( X0+X / X0 ) / 2

打印结果 X1

X1=1.0

|(X0-X1)/X1|>=eps?是

否

程序模块结构

主函数 main()

子函数求平方根newton_sqrt( )

求平方根子函数 newton_sqrt( )

// Example3.2 ： 用牛顿迭代公式求平方根 #include <iostream.h> #include <math.h> #define EPS 1.0e-10 double newton_sqrt(double x) { double x0, x1; x1 = 1.0; if(x>0.0) { do { x0 = x1; x1 = (x0+x/x0)/2; } while(fabs((x0-x1)/x1)>=EPS); return x1; } else return x; }

求平方根程序主函数 main （）

// 用于计算平方根的主函数 main() { double x, y; cout<<"Please input the value : "; cin>>x; y = newton_sqrt(x); if(y<0) cout<<"Negative Value have not square root !”<<endl;

else cout<<"The square root of”<<x<<“ is “<<y<<endl;

}

字符和字符串的区别 字符是用单引号括起来的单个字符，它在存储器中占 1 个字节； 字符串是用双引号括起来的一串字符，它在存储器中占 n+1 个字节，即字符串的结束符‘ \0’ 也占 1 个字节的位置。 ‘A’ 和“ A” 是有区别的；前者是字符常数，后者是字符串常数。

3.4 、数组 问题的引出： 实际应用的程序设计中，只用几个变量的情况是极少的；更多的情况是处理大批量的相同类型或不同类型的数据。 相同类型数据举例：统计交大 15 ， 000 学生英语 4级统考成绩； 不同类型数据举例：管理交大 15 ， 000 学生学籍信息记录，包括：姓名、学号、出生日期、班级、各科成绩等。 用什么样的数据结构来描述这类应用更简洁？

应用举例：例：输入 100 个实数，按相反的次序 每5个为一行打印出来。

分析： 按前边所学内容，应设置 100 个实型变量，如果用读

数 cin ，每行读入 5个数，需要 20 个 cin 语句；用 cout输出，同样也需要 20 个。

结论： 若用“数组”形式的数据结构，这类应用就简单多了。

数组定义 具有相同类型的数据的集合被称为数组。 和简单变量类似，数组用数组名来标识。一个数组名用来表示一组同类型的数据；这批同类型的数据被称为数组元素或分量。 数组描述的是顺序数据结构；即数组元素在逻辑上相邻，在物理也相邻。在内存中它们是连续存放的。 数组和变量一样，必须先定义，后使用。

数组说明 数组必须先说明，才能使用。说明的一般格式： 类型说明符 数组名 [ 常数表达式 ][……][,…..]

说明： 类型说明符可以是任意类型（例如 char 、 int ）

常数表达式的值是数组元素的个数 数组可以是一维、二维或多维数组；是几维数组，数组名右边就有几对方括号，分别确定各维的长度（元素个数）；

举例： char a[10] ， str[10][80] ； /*10 行 80 列的字符数组 */

int s1[100][10] ， i1[1000] ；

存贮结构 存贮结构也称物理结构；它描述数据在计算机中的表示（又称映象）。 逻辑结构和存贮结构的区别：（ 1 ）逻辑结构是从逻辑关系（某种顺序）上观察数据，它是独立于计算机的；可在理论上、形式上进行研究、运算。（ 2 ）存储结构是逻辑结构在计算机中的实现，它是依赖于计算机的；离开计算机，则无法进行任何操作。（ 3 ）任何一个算法的设计取决于选定的数据逻辑结构；而算法的最终实现依赖于采用的存储结构。

一维数组存储结构 逻辑结构： 由一串数据构成的向量表，每个元素的下标值确定了各元素在此数据表中的位置。例如 , A[5]排序次序为： A[0] ， A[1] ， A[2] ， A[3] ， A[4] 存贮结构： 数组元素存放为一片连续的存储单元，其元素在内存中的存放顺序与逻辑结构是一致的；即所谓“逻辑上相邻，物理上也相邻”。 A[5] 的存储结构为：

A[0] A[1] A[2] A[3] A[4]

二维数组存储结构 逻辑结构： 二维数组恰似一张表格（或矩阵）。数组元素中的第一个下标值表示该元素在表格中的行号，第二个下标为列号。 M[3][3]具有如下逻辑结构： M[0][0] M[0][1] M[0][2] M[1][0] M[1][1] M[1][2] M[2][0] M[2][1] M[2][2] 存贮结构： 二维数组在内存中按一维数组存放、占据一片连续的存贮单元；是“按行顺序”在内存中分配存贮单元。Ｍ数组在内存中排列如下：

m01 m02 m10 m11 m12 m20 m21 m22

m00

三维数组存储结构 三维数组可以看成是若干个二维数组；在内存中也按一维数组存放。 C[2][3][3] 的数组元素排列如下： 三维数组元素在内存中 的排列顺序为： C000 、 C001 、 C002 、

C010 、 C011 、 C012 、

C020 、 C021 、 C022 、

C100 、 C101 、 C102 、

C110 、 C111 、 C112 、

C120 、 C121 、 C122 。

C000 C001 C002C010 C010 C012C020 C021 C022

C100 C101 C102C110 C110 C112C120 C121 C122

例 3.3 找出数组中的最大数算法分析：1 、假设数组中第 1 个元素最大，令 max=a[0]

2 、将 a[i] （ 0<= i < n ）与 max 进行比较， 若 a[i] < max ， i=i+1 ，再执行 2

否则，令 max=a[i] ， i=i+1 ，再执行 2

3 、循环结束，求出最大元素并输出 max 。

程序逻辑功能框图

max=a[0]

max=a[i]

打印结果max

i < n ?

i = i + 1

是否

程序模块结构

主函数 main()

子函数求最大元素max_element( )

VC0303.CPP 子程序// 函数 max_element(): 求数组中的最大元素 int max_element(int array[ ],int count) { int i, big = array[0]; for(i=0;i<count;i=i+1) if(array[i]>big) big = array[i]; return big; }

VC0303.CPP 主程序 // 用于调试函数 max_element() 的主函数 #include <iostream.h>#include <math.h>main(){ int array[] = { 10, 88, 72, 69, 94, 84, 66, 61, 89, 55 }; cout<<"The maxium element is”<< max_element(array, 10)); }

3.5 、字符型数组和字符串处理函数 字符数组是用于存放字符串和字符型数据的。 VC++ 语言提供了许多字符串处理函数。使用这些函数，可以提供字符处理的效率。

1 、字符数组 用 char 语句定义的数组。字符数组的元素是单个字符数据。 例如： （笨办法赋初值） char name[ 4]={‘A’,’B’,’C’} ；

或： char name[4] ；

name[0]=‘A’; name[1]=‘B’; name[2]=‘C’ ； name[3]=0; 例如：

char name[40] = “Visual C++”;

strcpy(name,”Visual Basic”);

cin>>name; cout<<name;

2 、字符串处理函数 字符串处理函数的说明都包含在“ string.h” 头文件中，要使用字符串处理函数，必须使用“ #include”预处理语句（ #include <string.h>) 。

常用的字符串处理函数有： strcat （） 字符串连接 strcpy （）字符串拷贝 strlen （） 求字符串长度 strstr （） 在字符串中查找另一个子串 strchr （） 在字符串中查找字符

例 3.4 计算字符串的长度 算法分析：

1 ）设一个计数器变量 len=0

2 ）从数组 s[len] 第一个元素开始进行处理3 ）若当前的元素值 s[len] 非空（‘ \0’ ），则 len+1 ，继续执行 3 ；否则，退出循环。4 ）打印结果 len

程序逻辑功能框图

len = 0str[n]

len=len+1

打印结果 len

str[len]=‘\0’? 是否

程序模块结构

主函数 main()

子函数求字符串长度strlen(str )

VC0304.CPP 子函数 /* 函数 strlen(): 求字符串的长度 */ int strlen(char string[]) { int len = 0; while(string[len]!='\0') len = len+1; return len; }

VC0304.CPP 主函数// 用于调试函数 strlen() 的主函数 #include <iostream.h>main(){ char string[] = "This is a sample."; cout<<"The length of string:"<<string; cout<<"is"<<strlen(string))<<endl;}程序运行结果： The length of string: … is 17.

3.9 、 Developer Studio 的文件处理功能 用于建立、打开和关闭文件处理的对象，包括项目、文件、工作区和其他文档 用于处理工作区 用于处理当前文件 用于打印当前文件 用于快速打开或切换文件和工作区 退出 Developer Studio （ Exit ）

3.10 、 Visual C++ 程序的编译、连接和运行 包括编译、连接等功能 用于调试程序 用于执行应用程序 用于设置编译和连接工作的参数

程序设计举例 例 3.5 矩阵相乘　 VC0305.CPP 例 3.6 交换排序　 VC0306.CPP 例 3.7 将字符串小写字符转换成大写字符　

VC0307.CPP

1 、矩阵相乘　 C0305.C

算法说明：矩阵 S （ NxM ）和矩阵 T （ LxN ）相乘。S 是 N 行、 M 列； T 是 L 行、 N 列。要求 :S 的列数和 T 的行数必须相同。

C = A * B i j

k= 1

i k k j

i=1 、 2 、 ~N ； j=1 、 2 、 ~ M

L

算法说明（续）

S =

1 0 3

2 1 1

T = 3 1 2 2 0 1 1 2 1

SxT = 1*3+0*2+3*1 1*1+0*0+3*2 1*2+0*1+3*1

2*3+1*2+1*1 2*1+1*0+1*2 2*2+1*1+1*1

= R

r11 r12 r13

r21 r22 r23

矩阵相乘程序matrix_multi(double a[],double b[],double c[],int l,int m,int n){ int i,j,k; for(i=0;i<l;i=i+1) for(j=0;j<n;j=j+1) { c[i*n+j] = 0; for(k=0;k<m;k=k+1) c[i*n+j] += a[i*m+k]*b[k*n+j]; }}

矩阵相乘主程序 (VC0305.CPP)#include <iostream.h>void main(){ double a[20]={1,3,-2,0,4,-2,-1,5,-7,2,0,8,4,1,-5,3,-3,2,-

4,1}; double b[15]={4,5,-1,2,-2,6,7,8,1,0,3,-5,9,8,-6}; double c[12];; matrix_multi(a,b,c,4,5,3); cout<<"The result is r=”<<endl; for(int i=0;i<2;i=i+1) { for(int j=0;j<3;j=j+1) cout<<" "<<r[i][j]; cout<<endl; } }

2 、交换排序（ VC0306.CPP ）

算法分析：(1) 两两比较相邻元素 A(I) 和 A(I+1)(I=1,2,…N-1), 如果 A(I)>A(I+1), 则交换它们的位置 A(I) A(I+1); 例如 :

... …. A(1) A(2) A(3) … A(I) A(I+1) … A(N-1) A(N)

经过这样一次处理 , 称为“一趟冒泡” , 将最大值交换到 A(N) 的位置 ;

(2) 对剩下的 N-1 个元素 ,再两两进行比较 ,按同样规则交换它们的位置 ,经过 N-2次比较 , 将次最大值交换到 A(N-1) 的位置 ;

(3) 如法炮制 ,经过 N-1趟的“冒泡处理” ,每趟进行 N-i次的比较,全部数列有序。

VC0306.CPP 子程序// 函数 bubble_up() ：冒泡法排序 void bubble_up(int list[], int count){ int i,j,tmp; for(i=0; i<count; i=i+1) for(j=count-1; j>i; j=j-1) if(list[j-1]>list[j]) { tmp = list[j-1]; list[j-1] = list[j]; list[j] = tmp; } }

VC0306.CPP 主程序//测试冒泡法排序的主程序main(){ int i, list[16]= { 503, 87, 512, 61, 908, 170, 897, 275, 653, 426, 154, 509, 612, 677, 765, 703 }; bubble_up(list,16); cout<<"The result is :"; for(i=0;i<16;i++) cout<<" "<<list[i]; cout<<endl; }

3 、转换小写字母为大写字母 算法分析： C0302.C 是将大写字符转换为小写，用到转换公式： str[i]=str[i]-‘A’+‘a’ ；

将小写字符转换为大写，用下列公式： str[i]=str[i]-‘a’+‘A’ ；

VC0307.CPP 子程序// 将小写字母转换为大写字母void mystrupr(char string[]){ int i = 0; while(string[i]!=0) { if(string[i]>='a' && string[i]<='z') string[i] = string[i]-'a'+'A'; i = i+1; }}

VC0307.CPP 主程序// 用于调试函数 mystrupr() 的主函数 #include <iostream.h>main(){ char str[] = "This is a sample."; strupr(str); cout<<"The result is " <<str<<endl;}

上机练习题1．用牛顿迭代法求方程： 2x3—4x2 十 3x 一 6 ＝ 0 在

1.5附近的根。2．用数组来处理求斐波那挈数列的第 n项和前 n之和。 3．打印出以下的杨辉三角形（要求打印出 10 行）4 、求给定的一个二维数组 ( N X N ) 的转置5 、矩阵相加。

结结 束束 语语 学好程序设计语言的唯一途径是 上机练习。 你的编程能力与你在计算机上投入的时间成 正比。