03C++基本数据类型

基本数据类型

---

2.2.1整型数据

短整型(short int)

有符号短整型(signed short int)

无符号短整型(unsigned short int)

一般整型(int)

有符号一般整型(signed int)

无符号一般整型(unsigned int)

长整型(long int)

有符号长整型(signed long int)

无符号长整型(unsigned long int)

(1)十进制整数。

(2)八进制整数。在常数的开头加一个数字0，就表示这是以八进制数形式表示的常数。

(3)十六进制整数。在常数的开头加一个数字0和一个英文字母X(或x)，就表示这是以十六进制数形式表示的常数。

2.2.2实型数据

单精度(float)

双精度(double)

长双精度(long double)

(1)十进制小数形式

(2)指数形式

2.2.3字符型数据

有符号字符型(signed char)

字符型char

无符号字符型(unsigned char)

2.2.4宽字符型数据

宽字符型数据(wchar_t)

2.2.5布尔型数据

逻辑型(bool)

2.2.6空类型

空类型(void)就是无值型

3.2字符串String

字符串变量必须先定义后使用，定义字符串变量要用类名string。如

string string1；                    //定义string1为字符串变量

string string2=″China″;             //定义string2同时对其初始化

要使用string类的功能时，必须在本文件的开头将C++标准库中的string头文件包含进来，即应加上#include <string>

字符串变量的运算

在以字符数组存放字符串时，字符串的运算要用字符串函数，如strcat(连接)、strcmp(比较)、strcpy(复制)，而对string类对象，可以不用这些函数，而直接用简单的运算符。

(1) 字符串复制用赋值号

string1=string2;其作用与“strcpy(string1,string2);”相同。

(2) 字符串连接用加号

string string1=″C++″;                   //定义string1并赋初值

string string2=″Language″;               //定义string2并赋初值

string1=string1 + string2;               //连接string1和string2

(3) 字符串比较直接用关系运算符

==(等于)、>(大于)、<(小于)、!=(不等于)、>=(大于或等于)、<=(小于或等于)等关系运算符来进行字符串的比较。

• //输入3个字符串，要求将字母按由小到大的顺序输出。

#include <iostream>

#include <string>

using namespace std;

int main( ){

string string1,string2,string3,temp;

cout<<"please input three strings:";

cin>>string1>>string2>>string3;

if(string2>string3)

{temp=string2;string2=string3;string3=temp;}

if(string1<=string2)

{cout<<string1<<" "<<string2<<" "<<string3<<endl;}

else if(string1<=string3) {

cout<<string2<<" "<<string1<<" "<<string3<<endl;

}else cout<<string2<<" "<<string3<<" "<<string1<<endl;

return 0;

}

• //一个班有n个学生，需要把每个学生的姓名和学号输入计算机保存。然后可以通过输入某一学生的姓名查找其有关资料。当输入一个姓名后，程序就查找该班中有无此学生，如果有，则输出他的姓名和学号，如果查不到，则输出“本班无此人”。为解此问题，可以分别编写两个函数，函数input_data用来输入n个学生的姓名和学号，函数search用来查找要找的学生是否在本班。

#include <iostream>

#include <string>

using namespace std;

int n;string name[50],num[50];

int main( ){

void input_data( );

void search(string find_name);

string find_name;

cout<<"please input number of this class:";

cin>>n;

input_data( );

cout<<"please input name you want find:";

cin>>find_name;

search(find_name);

return 0;

}

void input_data( ){

int i;

for (i=0;i<n;i++){

cout<<"input name and NO of student"<<i+1<<":";

cin>>name[i]>>num[i];

}

}

void search(string find_name){

int i;bool flag=false;

for(i=0;i<n;i++){

if(name[i]==find_name){

cout<<name[i]<<"has been found, his number is "<<num[i]<<endl;

flag=true;

break;

}

if(flag==false){

cout<<"can't find this name";

}

}

}

3.3结构体(structure)类型

3.3.1结构体类型概念

在一个组合项中包含若干个类型不同的数据项。Ｃ和C++允许用户自己指定这样一种数据类型，它称为结构体。它相当于其他高级语言中的记录(record)。

声明一个结构体类型的一般形式为

struct 结构体类型名

｛成员表列｝；

struct Student{            //声明一个结构体类型Student

int num;                 //包括一个整型变量num

char name[20];           //包括一个字符数组name，可以容纳20个字符

char sex;                //包括一个字符变量sex

int age;                 //包括一个整型变量age

float score;              //包括一个单精度型变量

char addr[30];           //包括一个字符数组addr，可以容纳30个字符

｝;                    //最后有一个分号

3.3.2结构体类型变量

struct Student               //声明结构体类型Student

{ int num;

char name[20];

char sex;

int age;

float score;

char addr[30];

｝student1,student2;  //定义两个结构体类型Student的变量student1,student2

如

struct Date          //声明一个结构体类型Date

{ int month;

int day;

int year;

｝;

struct Student                //声明一个结构体类型Student

{ int num;

char name[20];

char sex;

int age;

Date birthday;            //Date是结构体类型，birthday是Date类型的成员

char addr[30];

}student1,student2; //定义student1和student2为结构体类型Student的变量

3.3.3结构体变量的初始化

struct Student

{ int num;

char name[20];

char sex;

int age;

float score;

char addr[30];

｝student1={10001，″Zhang Xin″,′M′,19,90.5,″Shanghai″};

Student student2={10002，″Wang Li″,′F′,20,98,″Beijing″;

3.3.4引用结构体变量中的成员。

#include <iostream>

using namespace std;

struct Date{

int year;

int month;

int day;

};

struct Student{

int num;

char name[20];

char sex;

Date birthday;

float score;

}student1,student2={10002,"Wang Li",'f',5,23,1982,89.5};

int main( ){

student1=student2;

cout<<student1.num<<endl;

cout<<student1.name<<endl;

cout<<student1.sex<<endl;

cout<<student1.birthday.month<<'/'<<student1.birthday.day<<'/'<<student1.birthday.year<<endl;

cout<<student1.score<<endl;

return 0;

}

3.3.5结构体数组

每个数组元素都是一个结构体类型的数据，它们都分别包括各个成员项。

struct Student

{ int num;

char name[20];

char sex;

int age;

float score;

char addr[30];

};

Student stu[3];      //定义Student类型的数组stu

也可以直接定义一个结构体数组，如

struct Student

{ int num;

char name[20];

char sex;

int age;

float score;

char addr[30];

}stu[3];

或

struct

{ int num;

char name[20];

char sex;

int age;

float score;

char addr[30];

}stu[3];

3.3.6结构体数组的初始化

与其他类型的数组一样，对结构体数组可以初始化。如

struct Student

{ int num;

char name[20];

char sex;

int age;

float score;

char addr[30];

}sty[3]={{10101,″Li Lin″,′M′,18,87.5,″103 Beijing Road″},

{10102,″Zhang Fun″,′M′，19,99,″130 Shanghai Road″},

{10104,″Wang Min″,′F′,20,78.5,″1010,Zhongshan Road″}};

3.3.7结构体数组应用

对候选人得票的统计程序。设有3个候选人，最终只能有1人当选为领导。今有10个人参加投票，从键盘先后输入这10个人所投的候选人的名字，要求最后输出这3个候选人的得票结果。可以定义一个候选人结构体数组，包括3个元素，在每个元素中存放有关的数据。

#include <iostream>

#include <string.h>

using namespace std;

struct Person{

char name[20];

int count;

};

int main( ){

Person leader[3]={"Li",0,"Zhang",0,"Fun",0};

int i,j;

char leader_name[20];

for(i=0;i<10;i++){

cin>>leader_name;

for(j=0;j<3;j++)

if(strcmp(leader_name,leader[j].name)==0) {

leader[j].count++;

}

}

cout<<endl;

for(i=0;i<3;i++){

cout<<leader[i].name<<":"<<leader[i].count<<endl;

}

return 0;

}

3.3.8指向结构体变量的指针

一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设一个指针变量，用来指向一个结构体变量，此时该指针变量的值是结构体变量的起始地址。指针变量也可以用来指向结构体数组中的元素

1. 通过指向结构体变量的指针引用结构体变量中的成员

#include <iostream>

#include <string>

using namespace std;

int main( ){

struct Student{

int num;

string name;

char sex;

float score;

};

Student stu;

Student *p=&stu;

stu.num=10301;

stu.name="Wang Fun";

stu.sex='f';

stu.score=89.5;

cout<<stu.num<<" "<<stu.name<<" "<<stu.sex<<" "<<stu.score<<endl;

cout<<(*p).num<<" "<<(*p).name<<" "<<(*p).sex<<" "<<(*p).score<<endl;

return 0;

}

2.说明如何建立和输出一个简单链表。输出各结点中的数据。

#define NULL 0

#include <iostream>

using namespace std;

struct Student{

long num;

float score;

struct Student *next;

};

int main( ){

Student a,b,c,*head,*p;

//对结点a的num和score成员赋值

a.num=31001;a.score=89.5;

//对结点b的num和score成员赋值

b.num=31003;b.score=90;

//对结点c的num和score成员赋值

c.num=31007;c.score=85;

//将结点a的起始地址赋给头指针head

head=&a;

//将结点b的起始地址赋给a结点的next成员

a.next=&b;

//将结点c的起始地址赋给b结点的next成员

b.next=&c;

//结点的next成员不存放其他结点地址

c.next=NULL;

//使p指针指向a结点

p=head;

do{

//输出p指向的结点的数据

cout<<p->num<<" "<<p->score<<endl;

//使p指向下一个结点

p=p->next;

} while(p!=NULL);//输出完c结点后p的值为NULL

return 0;

}

3.3.9结构体类型数据作为函数参数

有一个结构体变量stu，内含学生学号、姓名和3门课的成绩。要求在main函数中为各成员赋值，在另一函数print中将它们的值输出。

(1) 用结构体变量作函数参数

#include <iostream>

#include <string>

using namespace std;

struct Student{

int num;

string name;

float score[3];

};

int main( ){

//函数声明，形参类型为结构体Student

void print(Student);

Student stu;

stu.num=12345;

stu.name="Li Fung";

stu.score[0]=67.5;

stu.score[1]=89;

stu.score[2]=78.5;

//调用print函数，输出stu各成员的值

print(stu);

return 0;

}

void print(Student stu){

cout<<stu.num<<" "<<stu.name<<" "<<stu.score[0]<<" "

<<stu.score[1]<<" "<<stu.score[2]<<endl;

}

(2) 用指向结构体变量的指针作实参

#include <iostream>

#include <string>

using namespace std;

struct Student{

int num;

//用string类型定义字符串变量

string name;

float score[3];

//定义结构体student变量stu并赋初值

}stu={12345,"Li Fung",67.5,89,78.5};

int main( ){

//函数声明，形参为指向Student类型数据的指针变量

void print(Student *);

//定义基类型为Student的指针变量pt，并指向stu

Student *pt=&stu;

//实参为指向Student类数据的指针变量

print(pt);

return 0;

}

//定义函数，形参p是基类型为Student的指针变量

void print(Student *p){

cout<<p->num<<" "<<p->name<<" "<<p->score[0]<<" "

<<p->score[1]<<" "<<p->score[2]<<endl;

}

(3) 用结构体变量的引用作函数参数

#include <iostream>

#include <string>

using namespace std;

struct Student

{ int num;

string name;

float score[3];

}stu={12345,"Li Li",67.5,89,78.5};

int main( ){

//函数声明，形参为Student类型变量的引用

void print(Student &);

//实参为结构体Student变量

print(stu);

return 0;

}

//函数定义，形参为结构体Student变量的引用

void print(Student &stud){

cout<<stud.num<<" "<<stud.name<<" "<<stud.score[0]<<" "

<<stud.score[1]<<" "<<stud.score[2]<<endl;

}

3.3.10 动态分配和撤销内存的运算符new和delete

常常需要动态地分配和撤销内存空间C++提供了较简便而功能较强的运算符new和delete来取代C语言的malloc和free函数。

#include <iostream>

#include <string>

using namespace std;

//声明结构体类型Student

struct Student{

string name;

int num;

char sex;

};

int main( ){

//定义指向结构体类型Student的数据的指针变量

Student *p;

//用new运算符开辟一个存放Student型数据的空间

p=new Student;

//向结构体变量的成员赋值

p->name="Wang Fun";

p->num=10123;

p->sex='m';

//输出各成员的值

cout<<p->name<<endl<<p->num<<endl<<p->sex<<endl;

//撤销该空间

delete p;

return 0;

}

3.4共用体(union)类型

3.4.1共用体的概念

有时需要使几种不同类型的变量存放到同一段内存单元中。变量在内存中占的字节数不同，但都从同一地址开始存放。也就是使用覆盖技术，几个变量互相覆盖。这种使几个不同的变量共占同一段内存的结构，称为共用体(union)类型的结构。

声明共用体类型的一般形式为

union 共用体类型名

｛成员表列

｝；

union data

{ int i;

char ch;

double d;

｝a,b,c；

(有共用体类型名)

union

{ int i;

char ch;

double d;

}a,b,c；

(无共用体类型名)

结构体变量所占内存长度是各成员占的内存长度之和。每个成员分别占有其自己的内存单元。共用体变量所占的内存长度等于最长的成员的长度。

3.4.2对共用体变量的访问方式

不能引用共用体变量，而只能引用共用体变量中的成员。

a.i （引用共用体变量中的整型成员i）

a.ch（引用共用体变量中的字符型成员ch）

a.f （引用共用体变量中的双精度型成员d）

设有若干个人员的数据，其中有学生和教师。学生的数据中包括： 姓名、号码、性别、职业、年级。教师的数据包括： 姓名、号码、性别、职业、职务。

如果job项为s（学生），则第5项为grade（年级）。即Li是3年级的。如果job项是t（教师），则第5项为position（职务）。Wang是prof(教授)。显然对第5项可以用共用体来处理（将class和position放在同一段内存中）。

要求输入人员的数据，然后再输出。为简化起见，只设两个人（一个学生、一个教师）。

#include <iostream>

#include <string>

//因为在输出流中使用了控制符setw

#include <iomanip>

using namespace std;

struct{

int num;

char name[10];

char sex;

char job;

//声明共用体类型

union P{

int grade;

char position[10];

//成员category 为共用体变量

}category;

//定义共用体数组person，含两个元素

}person[2];

int main( ){

int i;

for(i=0;i<2;i++){

cin>>person[i].num>>person[i].name>>person[i].sex>>person[i].job;

//若是学生则输入年级

if(person[i].job=='s') cin>>person[i].category.grade;

//若是教师则输入职务

else if (person[i].job=='t') cin>>person[i].category.position;

}

cout<<endl<<"No.  Name   sex  job  grade/position"<<endl;

for(i=0;i<2;i++){

if (person[i].job=='s')

cout<<person[i].num<<setw(6)<<person[i].name<<" "<<person[i].sex

<<" "<<person[i].job<<setw(10)<<person[i].category.grade<<endl;

else

cout<<person[i].num<<setw(6)<<person[i].name<<" "<<person[i].sex

<<" "<<person[i].job<<setw(10)<<person[i].category.position<<endl;

}

return 0;

}

3.5枚举(enumeration)类型

如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓“枚举”是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。

声明枚举类型用enum

enum weekday{sun，mon，tue，wed，thu，fri，sat};

声明枚举类型的一般形式为

enum  枚举类型名  {枚举常量表列};

在声明了枚举类型之后，可以用它来定义变量。如

weekday  workday,week_end;

这样，workday和week_end被定义为枚举类型weekday的变量。

口袋中有红、黄、蓝、白、黑5种颜色的球若干个。每次从口袋中任意取出3个球，问得到3种不同颜色的球的可能取法，输出每种排列的情况。

//需要用到输入输出操作

#include <iostream>

//在输出时要用到setw控制符

#include <iomanip>

//

using namespace std;

int main( ){

//声明枚举类型color

enum color {red,yellow,blue,white,black};

//定义color类型的变量pri

color pri;

//n是累计不同颜色的组合数

int i,j,k,n=0,loop;

//当i为某一颜色时

for (i=red;i<=black;i++)

//当j为某一颜色时

for (j=red;j<=black;j++)

//若前两个球的颜色不同

if (i!=j){

//只有前两个球的颜色不同，才需要检查第3个球的颜色

for (k=red;k<=black;k++)

//3个球的颜色都不同

if ((k!=i) && (k!=j))

{n=n+1;                //使累计值n加1

cout<<setw(3)<<n;         //输出当前的n值，字段宽度为3

for (loop=1;loop<=3;loop++)   //先后对3个球作处理

{switch (loop)              //loop的值先后为1,2,3

{case 1: pri=color(i);break;  //color(i)是强制类型转换，使pri的值为i

case 2: pri=color(j);break;  //使pri的值为j

case 3: pri=color(k);break;  //使pri的值为k

default:break;

}

//判断pri的值，输出相应的"颜色"

switch (pri)

{case red:cout<<setw(8)<<"red"; break;

case yellow:cout<<setw(8)<<"yellow"; break;

case blue:cout<<setw(8)<<"blue"; break;

case white:cout<<setw(8)<<"white"; break;

case black:cout<<setw(8)<<"black"; break;

default:break;

}

}

cout<<endl;

}

}

//输出符合条件的组合的个数

cout<<"total:"<<n<<endl;

return 0;

}

3.6 用typedef声明类型

typedef声明一个新的类型名来代替已有的类型名。

typedef int INTEGER；        //指定用标识符INTEGER代表int类型

typedef float REAL；         //指定用REAL代表float类型

这样，以下等价： ① int     i,j;  float a,b;② INTEGER i,j； REAL  a,b;

3.7类(class)类型