函数、类、inline

函数：1、引用传递：能避免拷贝对象。如果被引用传递的对象无需改变，用const声明。

bool isShorter(const &str1,const &str2){}

2、数组的引用：（&arr）[10];

3、对于返回引用的函数：返回值不能是局部变量或局部变量的指针。

4、inline:内联函数可以减少函数调用的开销，适用于规模较小的函数。

若在类的定义中直接实现某个成员函数，那么这个成员函数会自动成为inline函数

如：在调用shortString()函数时，cout<<shortString(s1,s2)<<endl;

编译时会展开成以下形式：

cout<<(s1.size()<s2.size()? s1:s2)<<endl;从而消除了运行shortString()函数的开销。

类:

1、当对象调用成员函数时，编译器把这个对象的地址传递给该函数的名为this的隐式参数。this是指针，指向该对象。this的地址不能改变。实际上this的类型为：Sales_data *const this;

可将this声明为指向常量的指针：string isbn()const{return booknum},即在函数名的参数列表后加const，能提高函数的灵活性。

2、引用：

&*p:相当于p，即p指向的地址。

*&p:指针的引用。

引用：int a=9;

int &b=a;

int *p=&a;

int &c=*p;

IO类:包括iostream类、fstream类、stringstream类iostream类库包括istream类、ostream类。

3、构造函数：无返回值，每次创建对象时会调用构造函数，可用于成员变量初始化。自定义构造函数时，还必须再定义一个默认构造函数。

如果类成员中有const或引用，必须对其初始化。

构造函数初始化有两种形式：

（1）列表初始化

class Book

{

public:

Book (int ii);

private:

int i;

const int ci

int &ri;

};

Book::Book(int ii):i(ii),ci(ii),ri(i){} //列表初始化

（2）赋值

 

class Book

{

public:

Book (int ii);

private:

int i;

const int ci

int &ri;

};

Book::Book(int ii)

{ i=ii; ci=ii; ri=i; } //赋值初始化（将引发错误）

列表初始化可直接初始化数据成员，效率较高，能避免错误。

初始化顺序：一般是按照成员变量声明的顺序进行初始化。初始化时尽量使用构造函数的参数。

默认构造函数的形式：Sales_data (string s=" "):bookNo(s){};

委托构造函数：

class Sales_data

{

public:

Sales_data (string s,unsigned cnt ,double price):bookNo(s),sold(cnt),revenue(price*cnt){}

Sales_data ():Sales_data(" ",0,0){} //委托第一个构造函数初始化

Sales_data(string ss):Sales_data(ss,0,0){}

Sales_data(istream &is):Sales_data(){read(is,*this);} //间接委托

 

}

4、class和struct的唯一区别：如果使用class，则定义在第一个访问说明符之前的成员是private的，如果使用struct，则是public的。

用public 声明的成员可以在整个程序中被访问，用private声明的成员只能被类中的成员访问。

5、类内部的函数默认为内联函数，在类的外部也可以用inline将函数声明为内联函数。

6、友元：允许类外部的成员函数访问类内部的私有成员。

(1)函数之间 friend sum(); (2)类之间 friend class B;

用于扩大一个函数或类的访问权限。

7、可变数据成员：mutable

用mutable声明的变量，不会是const类型的，任何情况下值都可以改变。

8、函数返回类的引用可以直接改变调用该函数的对象的值，否则改变的是该对象的副本。（return *this）

9、const重载：可用于const对象。

class Screen

{

public：

Screen &display(ostream &os)

{do_display(os);return *this;}

constScreen &display(ostream &os)

{do_display(os);return *this;}

private:

void do_display (ostream &os) const

{os<<contents;}

}；

 

Screen myscreen(3,4);

const Screen black(5,6);

myscreen.display(count); //调用的是Screen &display(ostream &os)；

black.display(count); //调用的是constScreen &display(ostream &os)；

const类型的对象对应的是const类型的函数。

不能连续同时调用返回常量的函数和非常量的函数。（myscreen.display().set();），解决办法就是使用const重载。

10、类类型转换：

（1）string null_book="9-999-999";

Sales_data item; //类中combine 的定义：Sales_data& combine(const Sales_data &){};

item.combine(null_book); // 编译器用给定的string将null_book 隐式转换成临时的Sales_data对象。

（2） item.combine("9-999-999") ;// 无法转换成Sales_data对象。

（3）item.combine(string("9-999-999")); //可以转换成Sales_data

item.combine(Sales_data("9-999-999")); //相当于调用Sales_data 的构造函数

  item.combine(cin) //将istream转换成Sales_data 对象

可以将istream、ostream、string类型的变量隐式转换成Sales_data对象，这是由编译器通过调用相应的构造函数创建一个临时对象完成的，如果构造函数声明成explicit，那么就会阻止这种隐式转换。

对于explicit：explicit 只对含一个参数的构造函数起作用，含有多个参数的构造函数不能用于隐式转换，explicit只能在类内部使用。

11、类的静态成员：

（1）所有对象共享静态成员，静态成员不能声明成const，不包含this指针。

（2）类外部定义static成员时，无需加static关键字

（3）在类的外部初始化静态成员，也可在类内部初始化静态成员，但要声明成constexpr类型且初始值必须是常量。

（4）与普通变量的区别：static变量可以是不完全类型，可以作为默认实参。

class Bar

{

public:

.......

private:

static Bar b1; //static成员的不完全类型

Bar b2; //普通成员不能声明成不完全类型

Bar *b3； //指针可以是不完全类型

}；