内联函数

    概念：以inline修饰的函数叫做内联函数，编译是C++编译器会在调用内敛函数的地方展开，没有函数压栈

               的开销，内联函数提升程序运行的效率

    特性：1.Inline是一种用空间换取时间的做法，省去调用函数额外开销，所以代码很长或者有循环/递归的函数不适宜使用内联

               2.inline对编译器而言只是一个建议，编译器会自动优化，如果定义为Inline的函数体内有循环或者递归

                  等等，编译器会自动忽略掉内联

               3.inline必须和函数定义放在一起，才能成为内敛函数，仅仅将inline放在声明前是不起作用的

               4.定义在类内的成员函数默认定义为内联函数

注意：在C++中强烈建议使用const代替宏常量，使用const和内联函数在进行编译时不仅进行替换，而且还会进行参数 

           类型检测，提高程序的安全性，内联函数可以是普通函数，也可以是类的成员函数，函数式宏不能作为累的成员函数

 例子：

class Test
{
public:
	void output();
};
inline void Test::output()
{
	cout << "my" << endl;
}

 或者直接在类内定义内联函数

 

1.宏有什么优缺点？

优点：1.提高了程序可毒性，同时也方便进行修改；

            2.提高了程序的运行效率，使用带参的宏定义既可以完成函数调用的功能，又能避免函数出栈与

                入栈操作，减少系统开销，提高运行效率；

  缺点：1.由于是直接嵌入，代码相对多一点             

             2.参数每次用于宏定义时它们都将重新求值，由于多次求值，带有副作用的参数可能会产生不可预料的结果

             3.对带参的宏来说，由于是直接替换，不会检查参数是否合法，存在安全隐患

 

2.宏函数和内联函数的区别

    宏和内联函数都采用了空间换时间的方法，在其调用处进行展开

    1.在预编译时期宏定义在调用处执行替换。在编译时期，内联函数在调用处展开，同时进行参数的类型检查

    2.内联函数是函数，可以像调用普通函数一样调用内联函数。宏定义需要添加很多括号防止歧义，编写复杂

    3.内联函数可以作为类的成员函数，成为类的保护成员或私有成员，当一个表达式涉及到类的保护成员或私有

       成员时，宏就不能实现了（无法将this指针放在合适的位置）

友元：分为友元函数、友元类

友元函数：

    友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在

    类中声明，声明需要加上friend关键字

     例子：

class Date
{
	friend void PrintDate(const Date&d);
public:
	Date(int year, int month, int day)
		:_year (year)
		, _month (month)
		, _day (day)
	{}
	
private:
	int _year;
	int _month;
	int _day;
};
void PrintDate(const Date&d)
{
	cout << d._year << "_" << d._month << "_" << d._day << endl;
}
int main()
{
	Date x(2018, 9, 10);
	PrintDate(x);
	return 0;
}

    特性：1.友元函数可以访问类的私有成员，但不是类的成员函数

               2.友元函数不能用const修饰

               3.友元函数可以在类的任何地方声明，不受访问限定符限制

               4.一个函数可以是多个类的友元函数

               5.友元函数的调用和普通函数的调用原理相同

友元类：

    概念：友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员

            在A类定义friend B 说明B类是A类的友元，所以在B的成员函数中可以访问A类对象的私有成员

            也就是说，在A中定义B ，B是A的朋友，在B中可以访问A

例子：

class B
{
public:
	B()
		:_x(100)
	{}
private:
	int _x;
	friend class A;
	friend void show();
};
class A
{
public:
	A()
		:_y(200)
	{}
	void show(B&b)
	{
		cout << b._x << endl;
		cout << _y << endl;
	}
private:
	int _y;

};
int main()
{
	A a;
	B b;
	a.show(b);
	return 0;
}

使用友元优点是提高了程序的运行效率，缺点是破坏了类的封装性和隐藏性

注意：友元关系不能继承，友元关系是单向的不具有交换性，友元关系不能传递

 

内联函数 ：以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈开销，内联函数提升程序运行的效率

内联函数特征：

1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的的函数不适宜使用内联。

2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。

3. inline必须函数定义放在一起，才能成为内联函数，仅将inline放在声明前是不起不作用的。

4. 定义在类内的成员函数默认定义为内联函数。

说道内联就不得不说宏：
宏的优点：


1. 增强代码的复用性。

2. 提高性能。
宏也有很多缺点:

1. 不方便调试宏。（因为预编译阶段进行了替换）

2. 导致代码可读性差，可维护性差，容易误用。

3. 没有类型安全的检查。

注意：

在C++中，强制建议使用const代替宏常量，使用内联函数代替宏函数，const和内联函数在进行编译时不仅进行替换，而且还会进行参数类型检测，提高了程序的安全性。内敛函数可以是普通函数，也可以是类的成员函数；函数式宏不能作为类的成员函数


#include <iostream>
using namespace std;

#define Swap(a, b)      \
do{                     \
	int tmp = a;    \
	a = b;          \
	b = tmp;        \
}while(0)

inline int Add(int a, int b)
{
	return a + b;
}

int main()
{

	int x1 = 10;
	int x2 = 20;
	Swap(x1, x2);

	int x3 = 100;
	int x4 = 200;
	Swap(x3, x4);

	printf("%d\n", Add(10, 20));

	return 0;
}

友元 

友元分为：友元函数和友元类

友元函数：

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字
友元函数说明:

友元函数可访问类的私有成员，但不是类的成员函数

友元函数不能用const修饰

友元函数可以在类定义的任何地方声明，不受类访问限定符限制

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用和原理相同


友元类：
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员

友元的优缺点:

优点：提高了程序运行效率

缺点：破坏了类的封装性和隐藏性，在使用友元时，一定要注意场合和时机。
注意：

友元关系不能继承

友元关系是单向的，不具有交换性

友元关系不能传递


class Date
{
	friend void Show(const Date& d); // 友元函数
	friend class AA; // 友元类
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

public:
	Date(int year = 1900, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

	void Show() const
	{
		cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
	}


private:
	int _year;
	int _month;
	int _day;
};

void Show(const Date& d)
{
	cout<<d._year<<"-"<<d._month<<"-"<<d._day<<endl;
}

class AA
{
public:
	void Show(const Date& d)
	{
		cout<<d._year<<"-"<<d._month<<"-"<<d._day<<endl;
	}

	void Modift(Date& d)
	{
		d._year = 1990;
	}
};


ostream& operator<<(ostream& out, const Date& d)
{
	out<<d._year<<"-"<<d._month<<"-"<<d._day<<endl;
	return out;
}

istream& operator>>(istream& in, Date& d)
{
	in>>d._year;
	in>>d._month;
	in>>d._day;
	return in;
}

int main()
{
	Date d1(2018, 3, 26);
	Show(d1);

	int i = 0;
	cout<<i<<endl;

	cin>>d1;
	cout<<d1<<endl;

	return 0;
}

一.内联函数

1.内联函数：以inline修饰的函数叫内联函数，编译时c++编译器会会在调用内联函数的地方展开，没有函数压栈开销，内联函数提升程序运行的效率

2.内联函数的效率：

inline是一种以空间换时间的做法，省去调用函数额外开销，所以代码很长或者有递归/循环的函数不适宜使用内联
	
inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等，编译器优化时会忽略内联
	
inline定义的函数定义放在一起，才能成为内联函数，仅将inline放在声明前是不起作用的
	
定义在类内的成员函数默认为内联函数（如若定义在类外，会当成破普通函数对待）
3.宏的优缺点

优点：

增强代码的复用性
	
提高性能
缺点：

不会进行类型检测
	
代码膨胀（在预编译期间进行了替换）
	
不能调试
	
副作用（前置后置++）
4.注意：在c++中，强制建议使用const代替宏常量，使用内联函数替代宏函数，const和内联函数在编译期间不仅进行替换，而且还会进行参数检测，提高了程序的安全性，内联函数可以是普通函数，也可以是类的成员函数，函数式宏不能作为类的成员函数


#define MAX(a, b) (((a)>(b))? (a):(b))
/*
不会进行类型检测
代码膨胀
副作用
不能调试
*/
int main()
{
	int a = 10;
	int b = 20;

	cout<<MAX(a, ++b)<<endl;
	return 0;
}


int Add(int left, int right);

inline int Add(int left, int right)
{
	//Add(left, left);
	return left + right;
}

class CInt
{
public:
	CInt::CInt(int data)
		: _num(data)
	{}


public:
	int _num;
};


inline int Max(int left, int right)
{
	return left > right ? left :right;
}

int main()
{
	int a=10;
	cout<<&a<<endl;
	int b = 20;
	int c;
	c = Add(10, 20);
	cout<<Max(a, ++b)<<endl;
	CInt d(30);
	return 0;
}

二.友元

友元分为友元函数和友元类

1.友元函数：

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加上friend关键字

class Date
{
	friend void PrintDate(const Date& d);
public:
	Date(int year,int month,int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

private:
	int _year;
	int _month;
	int _day;
};


void PrintDate(const Date& d)
{
	cout<<d._year <<"-"<<d._month <<"-"<<d._day<<endl;
}

int main()
{
	Date d(2017,1,1);
	PrintDate(d);
	return 0;
}



友元函数说明：

友元函数可以访问类的私有成员，但不是类的成员函数
	
友元函数不能用const修饰
	
友元函数可以在类定义的任何地方声明，不受类访问限定符的限制
	
一个函数可以是多个类的友元函数
	
友元函数的调用原理和普通函数相同
2.友元类：

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类非公有成员

class Date
{
	friend void Show(const Date& d);//友元函数
	friend class AA;//友元类
	friend ostream& operator<<(ostream& out,const Date& d);
	friend istream& operator>>(istream& in, Date& d);

public:
	Date(int year,int month,int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

	void Show()const
{
	cout<<_year <<"-"<<_month <<"-"<<_day<<endl;
}

private:
	int _year;
	int _month;
	int _day;
};


void Show(const Date& d)
{
	cout<<d._year <<"-"<<d._month <<"-"<<d._day<<endl;
}


class AA
{
public:
	void Show(const Date& d)
	{
		cout<<d._year <<"-"<<d._month <<"-"<<d._day<<endl;
	}

	void Modift(Date& d)
	{
		d._year =2019;
	}
};

ostream& operator<<(ostream& out,const Date& d)
{
	out<<d._year<<"-"<<d._month <<"-"<<d._day<<endl;
	return out;
}

istream& operator>>(istream& in, Date& d)
{
	in>>d._year ;
	in>>d._month ;
	in>>d._day ;
	return in;
}
int main()
{
	Date d(2017,1,1);
	Show(d);

	int i=0;
	cout<<i<<endl;

	cin>>d;
	cout<<d<<endl;
	return 0;
}




3.友元优缺点：

优点：提高了程序运行效率
	
缺点：破坏了类的封装性和隐藏性，在使用有友元时，一定要注意场合时机
4.注意：

友元关系不能继承
	
友元关系是单向的，不具有交换性
	
友元关系不能传递

1、内联函数（inline）： 

如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。


inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的的函数不适宜使用内联。
inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉 

内联。
inline必须函数定义放在一起，才能成为内联函数，仅将inline放在声明前是不起不作用的。
定义在类内的成员函数默认定义为内联函数




class Date
{
public :
void Func () // 定义在类内部默认为内联函数
{}
void Display ();
private :
int _year ; // 年
int _month ; // 月
int _day ; // 日
};
inline void Date::Display () // 成员函数定义为内联
{
cout<<"year:" <<_year<< endl;
cout<<"month:" <<_month<< endl;
cout<<"day:" <<_day<< endl;
}
inline void Test() // 全局函数定义为内联
{}

注意; 

引入内联函数的目的是为了解决程序中函数调用的效率问题，这么说吧，程序在编译器编译的时候，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换，而对于其他的函数，都是在运行时候才被替代。这其实就是个空间代价换时间的i节省。所以内联函数一般都是1-5行的小函数。在使用内联函数时要留神：

1.在内联函数内不允许使用循环语句和开关语句； 

2.内联函数的定义必须出现在内联函数第一次调用之前； 

3.类结构中所在的类说明内部定义的函数是内联函数。

引入内联函数的目的是为了解决程序中函数调用的效率问题，这么说吧，程序在编译器编译的时候，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换，而对于其他的函数，都是在运行时候才被替代。这其实就是个空间代价换时间的i节省。所以内联函数一般都是1-5行的小函数。在使用内联函数时要留神：

1.在内联函数内不允许使用循环语句和开关语句； 

2.内联函数的定义必须出现在内联函数第一次调用之前； 

3.类结构中所在的类说明内部定义的函数是内联函数。

2、友元：  

类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。

如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend



class Box
{
   double width;
public:
   double length;
   friend void printWidth( Box box );
   void setWidth( double wid );
};



class Time
{
// Date是Time 的友元，所以 Date可以访问Time的所有成员。
friend class Date;
private :
int _hour ;
int _minute ;
int _second ;
};
class Date
{
public :
void Display ()
{
cout<<"year:" <<_year<< endl;
cout<<"month:" <<_month<< endl;
cout<<"day:" <<_day<< endl;
// 定义为友元类后，可以访问Time类对象的所有成员
cout<<"hour:" <<_t. _hour<<endl ;
cout<<"minute:" <<_t. _minute<<endl ;
cout<<"second:" <<_t. _second<<endl <<endl;
}
private :
int _year ; // 年
int _month ; // 月
int _day ; // 日
Time _t ;
};

注意;友元一定程度上破坏了C++的封装，友元不宜多用，在恰当的地方使用友元

3、static成员  

静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句，在创建第一个对象时，所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化，如下面的实例所示。



class Date
{
public :
Date ()
{
cout<<"Date ()" <<endl;
++ sCount;
}
void Display ()
{
cout<<"year:" <<_year<< endl;
cout<<"month:" <<_month<< endl;
cout<<"day:" <<_day<< endl;
}
// 静态成员函数
static void PrintCount()
{
cout<<"Date count:" <<sCount<< endl;
}
private :
int _year ; // 年
int _month ; // 月
int _day ; // 日
private :
static int sCount; // 静态成员变量，统计创建时间个数
};
// 定义并初始化静态成员变量
int Date::sCount = 0;

静态成员函数与普通成员函数的区别：


静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。
普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针。