C++ 数据类型与运算符详解-优快云博客

int i,s=0;

控制符

{

for (i=1;i<size;i++)

Dec

十进制输出

q=(int *)malloc(10*sizeof(int)); //申请分配10个int类型所占内存空间

十进制输出

不能声明引用的引用，不能定义引用的指针。

Oct

八进制输出

if(max<*(p+i)) //实质上就是对实参变量max赋值

setfil(c )

在给定的输出域宽度内添充字符c

0-4294967295

数据类型

cout<<stu1.num<<"\t"<<stu1.name<<"\t"<<stu1.sex<<"\t"<<stu1.score<<endl;

设域宽为n个字符

int a[10]={33,91,54,67,33,26,58};

{

delete p; //释放p所指向的所有内存空间

setiosflags(ios::scientific)

}

setiosflags(ios::left)

左对齐

任意字符

c=max(a,b);

右对齐

setiosflags(ios::skipws)

忽略前导空白

setiosflags(ios::uppercase)

十六进制数大写输出

setiosflags(ios::lowercase)

}

unsigned int

{

c++的4种数据类型

{

枢纽字

字节数

char name[20];

整型

int

格式1可以释放一个内存单元；而格式2可以释放若干个内存单元空间。

-32768-32767

{

cout<<"内存分配成功"<<endl;

单精度浮点型

float

cout<<"this is string"<<c<<endl;

双精度浮点型

±(1.2E-4932~1.2E4932)

double

±(3.4E-38~3.4E38)

a=20;

void

valueless

c++的基本数据类型

数据类型标识符

字节数

如：

char

for(i=1;i<n;i++)

{

当八进制数输出数据时，前面显示当前导符0

字符型

-127-128

cout<<a<<endl;

0-255

short [int]

//借助指针变量p输出它所指向的构造体变量成员的值

转义字符

{

设显示小数精度为n位

cout<<b<<endl;

unsigned short[int]

0-65535

int

-2147483648-2147483647

signed int

-2147483648-2147483647

setprecision(n)

-2147483648-2147483647

signed long [int]

int number;

whatitis(c);

cout<<endl<<endl;

-2147483648-2147483647

int x=1,z=10;

unsigned long [int]

十六进制数小写输出

这个程序总定义一个普通的函数fn1，而另外一个函数fn2,它以引用的方法返回函数值。

0-4294967295

float

±(3.4E-38~3.4E38)

double

±(1.7E-308~1.7E308)

long double

union 共同体名

1 li lin M 89

c++中常用的转义字符

寄义

{

long [int]

退格（BS)

换行（LF)

输入为：1 22 33 55 66 44 55 56 6 12

※ 说明：

{

类型定义typedef的利用：在c++中，出了直接利用c++提供的变准类型名：int、char、floot、double、long等去定义类型外，还可以用typedef定义新的类型名代替已有的类型名。

水平制表（HT)

垂直制表（VT)

}

反斜杠

cin>>a>>b;

使几个不同的变量共占一段内存的构造称为共用体类型，也叫联合体类型

双引号

空子符（NULL)

*ip2=300; //等价于b=300;

\ddd

struct student

\xhh

任意字符

cout<<"input a data";

cout<<"\n排序输出：";

寄义

cout<<&ra<<endl;

}

负号

int z;

加

减

乘

除

求余

}

自加

单引号

c++应许在定义函数时给其中的某个后哦某些形参拟定默认值，这样，当发死函数调用时，如果省略了对应位置上的实参的值，则在执行被调函数，以该形参的默认值进行运算。

}

-2147483648~2147483647

x=x-(x+y)

按位左移

x=x/(x+y)

cout<<a<<","<<c<<","<<d<<endl;

x=x>>(x+y)

x=x*(x+y)

-32768-32767

}

x=x|(x+y)

>>=

x=x^(x+y)

cin>>a[i];

……

x=x<<(x+y)

x=x%(x+y)

{

程序段2

int i=1;

1 li lin M 89

小于便是

按位异或

大于

程序段n

5) 可以引用成员的地址，也可以引用构造体变量的地址。

便是

4)引用声明终了后，相当于目标变量有两个名称，即该目标原名称和引用名。

}

不便是

cout<<"内存分配失败"<<endl;

min=*(p+i);

age1=s->age;

程序段2

逻辑非

{

student *p; //定义student类型的指针变量p

效果为：

逻辑或

int *ip1,*ip2; //定义了两个指向整型的指针变量

按位或

2) p=max;暗示把函数的进口地址赋给指针变量p，那么，*p就是函数max,因此，c=(*p)(a,b);和c=max(a,b);是等价的。*/

{

*ip1=200; &nb完美世界小说sp; //等价于a=200;

按位取反

unsigned char

3) 对构造体的成员变量的利用可以象对普通变量那样进行，入进行赋值、参加运算等。

2007-6-7 17.07

今天学习调试了内联函数：其定义方法和格式为：

Inline 函数值的类型函数名（形参及其类型列表）

｛函数体｝

下面的例子是调试过的可以输出：

inline double square(double x)

{

return x*x;

}

#include<iostream.h>

void main()

{

double x;

按位与

cin>>x;

cout<<"the square is "<<square(x);

}

输出效果为：input a data 8 the square is 64

2006.06.08.08:51

函数重载是指一个函数可以和同一做用域中的其它函数具有相同的名字，但这些同名函数的参数类型、参数个数、返回值以及函数功能可以完全不同。

#include<iostream.h>

void whatitis(int i)

{

cout<<"this is integer"<<i<<endl;

}

{cout<<"this is an integer"<<i<<"\n";}

{

±(1.7E-308~1.7E308)

x=x+(x+y)

main()

{

char c[]="abcdef";

whatitis(i);

无值型

指数显示

-128~127

※在本例中定义了两个名称叫whatitis的函数，但他们的形参累行不通。因此这两个函数就是重载函数。

cout<<"最大值："<<ma<<",最小值："<<mi<<endl;

{

#include<iostream.h>

void print(double d)

{

cout<<"this is a double"<<d<<"\n";

void print(int i)

void whatitis(char c[])

void main()

{

-127-128

float y=1.0;

char c='a';

print(x); //按规则（1）自动匹配函数void print(int i)

print(y); //按规则（2)通过内部转换匹配函数void print(double i)

//因为系统能自动将float型转换成double型

print(c); //按规则（2)通过内部转换匹配函数void print(int i)

//因为系统能自动将char型转换成int型

print(double(z));//按规则（3)匹配void print(double i)

}

输出效果为：

this is integer1

this is double1

this is integer97

this is double10

x=x+y

数值规模

for(i=0;i<8;i++)

void sum(int num=10) //形参默认值

{

输出为：内存分配成功

for(i=1;i<=num;i++)

s=s+i;

}

void main()

{

for(j=i;j<=8;j++)

sum(); //省略实参值，利用形参默认值10,输出为55

※ 引用总结

输出为：

Sum is 5050

Sum is 55

※在这个函数中我们看到主函数调用子函数时，如果没有给出初始值，则系统默认为子函数定义的初始值，如果主函数定义了初始值则运用主函数定义的初始值来进行运算。

{

2) 指针变量内只能存放其它变量的地址，而不能直接存放一个普通数据。

3) 一个指针变量只能指向同一个类型的变量。

4) 一个指针变量只有先指向某个变量后，才可利用该指针变量对它所指向的变量进行操做（间接访问）。

//指针变量及其利用方法

{

void main()

signed char

int a,b;

a=100;b=200;

ip1=&a;ip2=&b; //将变量a,b的地址分别赋给两个指针变量

//这时指针变量ip1指向变量a而指针变量ip1指向b

cout<<*p<<endl; //等价于cout<<*a;

cout<<*ip1<<''<<*ip2<<endl; //与cout<<a<<’’<<b<<endl;等价

格式1 delete 指针变量名；

}

※&和*的运算的优先级相同，但结合特性是自右向左，所以，&*ip1等价于&（*ip1），并等价于&a。

2007.06.09.14:41

用指针来完成求两个数中的较大者。

｛成员表｝变量表；

#include<iostream.h>

int max(int x,int y)

{

if(x>y)

z=x;

else

z=y;

return(z);

void main()

{

int a,b,c;

setiosflags(ios::right)

当程序中利用free函数释放内存时，应当在程序的头部嵌入相应的头文件：#include<stdlib.h>

void show(); //成员函数show的原型

void main()

int(*p)(); //定义了一个指向反方向的返回值为int型的函数的指针变量p

cout<<pa<<endl;

p=max;

cin>>a>>b;

c=(*p)(a,b);

cout<<c;

}

※说明：1) int(*p)();说明了一个指向返回值为整型数据的函数的指针，不要写成int*p().

定义findmax()函数，其功能是探求数组中的最大元素，并将该元素的下标通过参数返回其地址值，编程实现findmax()函数。

#include<iostream.h>

int *findmax(int *array,int size,int *index);

void main()

{

输出效果是：this is integer1 this is string abcdef

int *maxaddr;

int idx;

maxaddr=findmax(a,sizeof(a)/sizeof(*a),&idx);

stu1.score=89;

cout<<a[idx]<<endl;

}

int *findmax(int *array,int size,int *index)

int i=0;

int max,i;

//因为程序中将实参z强制转换为double 型

if(max<*(array+i))

{

max=*(array+i);

*index=i;

}

return(array+*index);

}

3) 引用与指针的区别在于：指针通过某个指针变量指向一个对象后，对它所指向的变量间接操做，程序中利用指针使程序的可读性差；而引用本身就是目标变量的别名，对引用的操做就是对目标变量的操做。

0x0012ff5c

2007-6-11.09:00

1) 在引用的利用中，单纯给某个变量取个别名是毫无意义的。引用的目的主要是在函数参数传递中解决大对象的传递效率和空间不如意的问题。

#include<iostream.h>

char main()

{

int a[10];

int *p,i;

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

p=a;

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

输入时主意：各个数之间为空格或回车，输出才正确，若为逗号则输出错误

}

{

setw(n)

}

1) 形参和实参都是数组名。

2) 实参用数组名而形参用指针变量。

3) 实参和形参都用指针变量。

4) 实参用指针变量，而形参用数组名。

I/O流的常用控制符

函数func是实现数组排序过程的函数。主函数将8个整数读入，调用func排序并输出效果：

cout<<*ip1<<''<<*ip2<<endl; //与cout<<a<<’’<<b<<endl;等价

#include<iostream.h>

void func(int *); //func的函数原型

void main()

{

int data[8];

int i;

cout<<"\n输入8个术：";

for(i=0;i<8;i++)

cin>>data[i];

func(data);

转义字符

void func(int *s)

cout<<data[i]<<",";

1)#ifdef 标识符

}

#include<iostream.h>

{

int i,j;

int work;

for(i=0;i<8;i++)

sum(100); //提供了实参值，被调函数以100进行运算，输出值为5050

if((+i)<*(s+j))

{

work=*(s+i);

*(s+i)=*(s+j);

*(s+j)=work;

}

#include<iostream.h>

}

※输入时各个数据间为空格或回车都可以，为空格时超越8个数据也不出效果只有加一个回车才出数据输出，但少于8个数据回车则还要输入数据，什么时候>=8个数据后回车才有输出。

将字符串a复制到字符串b

#include<iostream.h>

void copy_string(char *from,char *to)

setiosflags(ios::fixed)

for(;*from!='\0';from++,to++)

*to=*from;

to='\0';

}

void main()

功能

char a[20]="c language";

char b[20]="very good!";

copy_string(a,b);

cout<<a<<endl;

cout<<b<<endl;

}

输出效果为：c language

c language

※如果b字符串比较长，则输出时，b字符串的前i个为a[i]内容，而其它仍为b本来的字符串。

cout<<c;

引用及声明方法

类型标识符 &引用名＝目标变量名

例： int a;

int &ra＝a; //定义引用ra，它是变量a的引用，即别名。

回车(CR)

1)&在此不是求地址运算，而是标识做用，标识在此声明的是一个引用名称。

2)类型标识符是指目标变量的类型。

3)声明引用时，必须同时对其进行初始化。

5)声明一个不是新定义一个变量，它只是暗示该引用名是目标变量名的一个别名，所以，系统并不给引用分配存储单元。

该函数如2分配内存成功：则返回其起始地址；否则返回NULL。当程序中利用malloc函数动态分配内存时，应当在程序的头部嵌入相应的头文件：#include<stdlib.h>

#elif 常量表达式n

#include<iostream.h>

引用做为函数的参数

{

}

int &ra=a; //定义引用ra，初始化成变量a，所以ra是变量a的引用（别名）

cout<<a<<endl;

cout<<ra<<endl; //等价于cout<<a<<endl;

cout<<&a<<endl; //输出变量a所占存储单元的地址

cout<<&ra<<endl; //等价于cout<<&a<<endl;

ra=b; //等价于a=b;

cout<<ra<<endl;

x=x&(x+y)

cout<<&a<<endl;

cout<<&b<<endl;

指针变量的引用：类型标识符 *&引用名＝指针变量名

cout<<maxold.num<<"\t"<<maxold.name<<"\t"<<maxold.sex<<"\t"<<maxold.age<<endl;

void main()

{

int *a; //定义指针变量a

int b=10;

p=&b; //等价于a=&b，行将变量b的地址赋给指针变量a

cout<<*a<<endl; //输出变量b的值

cout<<a<<''<<b<<endl;

}

※ 不能建立数组的引用，因为数组是一个由若干个元素组成的集合，所以就无法建立一个数组的别名。

不能建立空指针的引用

不能建立空类型void的引用。

void main()

#include<iostream.h>

void main()

char bookname[20];

c++中常用的转义字符

int *&p=a; //定义引用p，初始化为指针变量a,所以p是a的引用（别名）

int b=10;

p=&b; //等价于a=&b，行将变量b的地址赋给指针变量a

cout<<*a<<endl; //输出变量b的值

cout<<*p<<endl; //等价于cout<<*a;

}

输入为：10 20

输出为：20 10

※引用的主要目的是：当参数的数据较大时，用引用比用一般变量传递参数的效率和空间占有率都好。

利用引用使函数返回多个值。

#include<iostream.h>

void max_min(int *p,int n,int &max,int *&min); //声明函数max_min

void main()

int a[10];

int ma,mi;

int i;

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

max_min(a,10,ma,mi); //调用函数max_min

cout<<pd<<”\t”;

输出为：8 7 6 5 4 3 2 1

void max_min(int *p,int n,int &max,int &min) //形参max和min定义成引用

指针的应用：

{

int a,b,c;

min=*(p+i);

cout<<"sum is "<<s<<"\n";

{

max=*(p+i);

if(min>*(p+i)) //实质上就是对实参变量min赋值

}

响铃（BEL）

◎此函数无法编译，因为调用max_min时无法调用，定义的数据类型过错。

#include<iostream.h>

float temp; //定义全局变量temp

float fn1(float r); //声明函数fn1

float &fn2(float r); //声明函数fn2

float fn1(float r) //定义函数fn1,它以返回值的方法返回函数值

temp=(float)(r*r*3.14);

return temp;

}

};

输出为：1 22 33 55 66 44 55 56 6 12

temp=(float)(r*r*3.14);

cout<<*(p+i)<<endl; //等价于cout<<a[i];

void main()

输出为：100 132 200 332

float a=fn1(10.0); //第1种情况，系统死成要返回值的副本

float &b=fn2(10.0); //第2种情况，可能会出错（不同c++系统有不同规定）

float c=fn2(10.0); //第3种情况，系统不死成返回值的副本

//可以从被调函数中返回一个全局变量的引用

1) 指针变量是一个变量。一个指针变量和普通变量一样，在内存中也占存储单元，因此，一个指针变量也相当于一个容器，所以，指针变量也有其指针，这就是指针变量的指针

{

}

输出为：314,314,314

用const限定引用

char sex;

double &fn(const double &pd)

{

static double ad=32;

ad+=pd;

在函数调用处由程序员对实参进行强制类型转换，以此做为查找相匹配的函数的依据。

return ad;

}

void main()

{

double a=100.0;

double &pa=fn(a);

cout<<pa<<”\t”;

a=200.0;

pa=fn(a);

max=*(p+i);

}

{

P+i或a+i就是a[i]元素的存储地址，即它们都指向数组的第i号元素：

2) 用引用传递函数的参数能保证参数传递中不产死副本，提高传递效率，且通过const的利用，保证了引用传递的平安性。

输出为：

2007-06-12-12:05

构造体、共同体和枚举

定义构造体的一般构造为：

struct 构造体名

｛

成员列表

｝变量名列表；

※引用构造体变量时应主意：

1) 不能将构造体做为一个整体来引用，只能引用构造体变量中的成员

2) 若构造体成员本身优势一个构造体变量，则要利用多个成员运输符一级一级地找到最低一级的成员进行引用。

按位右移

4) 可以将一个已有的构造体变量的值直接赋给另外一个相同类型的构造体变量。

指向构造体变量的指针：（可以定义指针变量指向构造体变量）

void main()

#include "string.h"

void main()

struct student //定义构造体类型student

#include<iostream.h>

char name[20];

char sex;

float score;

float &fn2(float r) //定义函数fn2,它以引用方式返回函数值

student stu1; //定义构造体类型student的变量stu1

p=&stu1; //将构造体变量stu1的地址赋给指针变量p

stu1.num=1; //分别给构造体变量stu1的num、name、sex、score成员赋值

strcpy(stu1.name,"li lin");

程序段1

cout<<maxaddr<<endl;

//输出stu1个成员的值

return temp;

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

#include "iostream.h"

}

char

else

1 li lin M 89

小于

max=*(array+0);

指向构造体数组的指针：

cout<<p->num<<"\t"<<p->name<<"\t"<<p->sex<<"\t"<<p->score<<endl;

{

int num;

char sex;

int age;

};

student stu[3]={{1,"li lin",'M',18},{2,"sun",'M',19},{3,"zhao",'M',20}};

程序段n+1

{

student *p;

for(p=stu;p<stu+3;p++)

cout<<p->num<<"\t"<<p->name<<"\t"<<p->sex<<"\t"<<p->age<<endl;

}

输出为：

1 li lin M 18

程序段1

1 zhao M 20

float &d=fn2(10.0); //第4种情况，系统不死成返回值的副本

这种函数的定义方法与返回普通数据类型的函数的定义方法是一样的，只不过这种函数的返回值是构造体数据类型的。其定义如下：

构造体名称函数名（形参及类型说明）

｛函数体｝

定义一个返回构造体类型的函数，求所有同学中年岁最大的同学

#include "iostream.h"

struct student

long int num;

int num;

char name[20];

#include "iostream.h"

int age;

};

student max(student *,int);

student stu[3]={{1,"li lin",'M',18},{2,"sun",'M',19},{3,"zhao",'M',20}};

void main()

//可以从被调函数中返回一个全局变量的引用

student maxold;

maxold=max(stu,3);

int a,b=10;

student max(student *s,int n)

int*&p=a; //定义引用p，初始化为指针变量a,所以p是a的引用（别名）

数值规模

index=0;

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

if(age1<(s+i)->age)

signed short[int]

index=i;

age1=(s+i)->age;

}

return(*(s+index));

}

输出为：3 zhao M 20

2007-06-13-08:57

堆内存的分配和释放

利用malloc函数。格式是：void *malloc(字节数)

利用new运算符。格式：

格式1 指针变量名＝new 类型标识符;

格式2 指针变量名＝new 类型标识符（初始值）;

格式3 指针变量名＝new 类型标识符[内存单元个数];

else

利用free函数。格式是：free(起始内存地址);

利用delete运算符。

格式2 delete[] 指针变量名；

当十六进制数输出数据时，前面显示当前导符0x;

例：

输入为：1 2 3 4 5 6 7 8

#include<stdlib.h>

#else

{

int *number,*p,*q;

number=new int[100]; //申请分配100个int类型所占内存空间（200字节）

p=new int; //申请分配一个int类型所占内存空间（2个字节）

Hex

if(number==NULL||p==NULL||q==NULL)

setiosflags(iosa::showbase)

※两种方法的区别是：利用malloc函数分配内存时，其返回值要经由类型转换后才能赋给一个指针变量，而利用new分配内存则不需要类型转换。

delete []number; //释放number所指向的所有内存空间

固定的浮点显示

free(q); //释放q所指向的所有内存空间

}

共同体

格式：

枚举就是之将某一变量所有可能的取值一一列举出来。定义格式是：

enum 枚举类型名｛枚举元素表｝枚举变量名；

宏定义命令：一般形式为：#define 宏名字符串

文件包含命令：是指将另一个源文件的内容合并到当前的程序中。一般形式为：

#include<文件名> 或 #include”文件名”

条件编译命令：它使得同一源文件在不同的条件下编译得到不同的目标代码。

{

}

程序段1

#include "iostream.h"

print(int iprint(double d)是重载函数

#endif

2)#ifndef 标识符

1 sun M 19

※利用数组名做为函数的参数可以用一下4种方法实现：

程序段2

#endif

3)#if 常量表达式1

stu1.sex='M';

#elif 常量表达式2

！

<<=

应用的定义及输出

大于便是

#else

void main()

#endif

返回构造类型值的恒心的定义：

cin>>a[i];

int i,age1,index;

int *a; //定义指针变量a

面向对象的程序设计

类的定义

C++的类在构造体的基础上扩充而来的。构造体将具有某种的不同数据的不同类型的成员组织在一起，而类是把各种不同类型的数据和对数据的操做组织在一起而构成的用户自定义的数据类型。

※ 说明：

Class是定义类的枢纽字，类名由用户自定义，但必须是c++的有效标识符，且一般首字母大写。

用类的数据成员暗示对象的属性，用成员函数暗示对象的服务，即对象的行为和功能。这些成员分3部分，私有部分（private）、公有部分（public）、庇护部分（protected）。

“：：”符合叫做用域运算符，它是用来指明哪个函数属于哪个类或哪个数据属于哪个类，所以，利用类中成员的全名是：类名：：成员名。

类名是成员名的一部分

class Record

例：

private:

public:

void regist(char *a,int b); //成员函数regist的原型

/*如果改用指向函数的指针变量，则main函数为：

}; //定义图书类Record

void Record::regist(char *a,int b) //regist()是类Record的成员函数

形式有3种

strcpy(bookname,a);

number=b;

void Record::show() //show()是类Record的成员函数

逻辑与

cout<<"名称："<<bookname<<endl;

cout<<"号码："<<number<<endl;

}

//不能从被调函数中返回一个临时变量或局部变量的引用

cout<<idx<<endl;

c++基础知识