C++进阶技巧-优快云博客

常用的：#include<iostream.h>

#include<iomanip.h>中

定义了流控制符，来控制数据的输出格式

Dec Hex Oct 分别为十进制十六进制八进制

setw(n)输出域宽为n

setfill(c)在给定的输出宽度内，填充字符c

........等

例：cout<<setw(3)<<setfill('#')<<hex<<a<<endl;

cout<<setw(4)<<b<<endl;

注意在定义了setfil，hex..之后，（在新的定义来之前）所有的语句都按照改定义执行

如：上面的第二句，同样以十六进制吗，填充‘#’的方式输出。

内敛函数 inline：调用这样的函数时，把代码直接插入到调用点，而没有程序跳转，返回一系列问题了

这样的函数中，不能有复杂的语句如：switch while，不能递归

一般只有1~5行语句的小函数

重载函数：（对于一些具有同一功能的函数，但函数参数不同）

即，可以定义一些函数名相同的函数，但至少形参的个数，类型或顺序上不同。

在调用时，传入相应的实参，系统就可以和传入的实参分辩，调用相应的正确的函数！

默认参数的函数：P78 ：不传入参数的话，就用默认参数！！

例：

#include<>

void sum(int num=10);//如果有函数说明，默认参数就在说明中提供

void main()

{

sum(100);//用100传入

sum();//使用默认参数

}

void sum(int num)//这里就不用提供默认参数了

{

}

关于const指针：

1.指向只读数据的指针变量！

const int *p;

即：指针指向的数据不能写入（改变），但指针可以改变指向！

2.指针常量

char *const p="adcfdg";

用这种方法定义的指针变量，指针指向不能改变，但指针所指的数据内容可以改变。

如：（接上） p="xtyz" //错的，它改变了指针的指向！

（接上） *p='s'; //对的（多了个*），只是改变了指向内容的值！

3.指向常量的指针常量

顾名思义：指向不能改变，指的内容也不能改变

引用：

int a ;

int &ra=a;

从此ra是a的别名！！

引用作为函数的参数：

void swap(int &p1,int &p2)

{.....}

调用函数，实参传给两个引用，函数中对p1,p2的操作就是直接对两个实参的操作！

注意：p1,p2不会分配内存。而用一般变量传递函数，会分配内存！

有关内存分配：

看例子：

#include<iostream.h>

#include<stdlib.h>

int *number,*p,*q;

number=new int[100];//分配一个有100个int型元素的数组！！！！

p=new int(11);//分配一个int型的内存空间，初值为11

q=(int*)malloc(10*sizeof(int));

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

{

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

}

else ;

delete []number;//注意这个写法！！！

delete p;

free(q);

构造函数：

其在类中，且函数名与类名相同，用于在对象定义时，自动被调用给对象初始化。

例：

class Person

{

private:.......

public:

Person(XXX,XXX,XXX,XXX);

.....

}

void Person::Person(XXX,XXX,XXX,XXX)

{

.........

//给相应的数据成员赋值

}

void main()

{

Person obj("zoushuai",XXX,XXX,XXX);//定义对象，带上初始值。

//之后，就定义并生成对象obj,然后自动调用构造函数Person.再将初始值传递给构造函数相应的形参！，最后执行构造

//函数体，将相应的值附给相应的数据成员！！！

}

析构函数：

同构造函数（为对象分配相应资源）功能相反，析构函数用来释放之前分配的资源！

函数如下：其被系统自动调用！如果在类的对象中没有分配动态内存（new）,可以用系统提供的默认的析构函数.(如果程序员在类中，没有为类提供析构函数，就会默认生成一个。你看不到，但存在！)。如果有！：则必须为该类提供析构函数以完成清理工作（delete）！

~类名（）

{

//函数体

}

利用初始化表对常量数据成员或引用成员提供初值！

例：

class Silly

{

public:

Silly()//这样的构造函数是错误的！

{

ten=10;

refi=i;

}

protected:

const int ten;//常量数据成员

int &refi;//引用refi

}

上面的是错误的：因为，在构造函数执行之前，对象结构已经建立（已生成），数据成员已存在，而且，ten是const只读的！ refi为引用！在构造函数内是不能在对其指派新值的！

但可以这样：

在类外定义时：(在类内的public中即写：Silly（）；实现则在类外！如下)

Silly::Silly():ten(123),refi(i)//数据成员名（值），数据成员名（值），。。。。。。。

{}

继承与派生：原来类的程序代码可通过继承而在新类中得到重用。

在基类的基础上定义其派生类的定义形式：

class 派生类名（自定）：访问方式基类名

{派生类中的新成员}//即，在基类的基础上可以添加新的成员

“访问方式”即继承方式可以使private（私有继承）和public（共有继承），如果省略则是private

基类与派生类的关系

按public方式继承时：基类中的共有成员和保护成员在派生类中不变

按private方式继承时：基类中的共有成员和保护成员在派生类中都为私有成员

基类中的私有成员在派生类中是不可访问的！！！！！！！！！！！！！

基类的构造函数是不会被继承的！！

所以，在设计派生类的对象时，派生类的构造函数除初始化其自身定义的数据成员外，还必须对基类中的数据成员进行初始化（即还要调用基类的构造函数！！！）

派生类名：：派生类构造函数名（参数表）：基类构造函数名（参数表）

{。。。。。。。。。。。。}

注：派生类构造函数的参数中包括参数的类型和参数名，而基类构造函数的参数中只有参数名！而且这些参数必须来源于派生类构造函数名后面括号后的参数(即要在派生类构造函数参数表中定义)。

多重继承:

class 派生类名：访问方式基类名1，访问方式基类名2......

{..........}

在多重继承下，系统首先执行各基类的构造函数，再是派生类的。。。。。。。。。

虚基类：

它是这样的：它虽然被一个派生类间接地多次继承，但派生类却只继承一份该基类的成员。

将一个基类声明为虚基类：

class 派生类名： virtual 访问方式基类名

{//声明派生类成员}

虚函数：

因为用基类指针指向公有派生类对象，指针仅能看到派生类中的基类部分。但是，如果做以下改变。能访问的就不同了。

虚函数的定义：

class 类名

{

public：

virtual 类型函数名（参数表）

{。。。。。；}

。。。。。。

}

当一个类的成员函数声明为虚函数后（如上），就可以在该类的派生类中定义与其基类虚函数原型相同的函数（函数名，返回类型，参数个数等完全相同）（虽然没有加上关键字virtual，都将被视为虚函数）。这时，当用基类指针指向这些派生类对象时，系统会在程序运行过程中，动态的自动选择函数，从而实现了运行时的多态性。（当通过基类指针多次调用虚函数时，由于指针所指向对象的不同，而调用不同对象所属类的虚函数）。

纯虚函数：

纯虚函数的声明如下：

virtual 函数原型=0；

纯虚函数是只在基类中声明但未给出具体的函数的实现，因此，用带有纯虚函数的基类中派生出的派生类，都必须定义与纯虚函数同名的重载函数。（这样，基类只是用于继承，仅作为一个接口，具体功能在派生类中实现！）

例子：

class Shape

{

protected:

........

public:

.........

virtual void area()=0;//声明纯虚函数