25_内联函数与函数重载

内联函数

1.关键字inline

2.函数:优点:空间小 缺点:效率低 拿时间换空间

宏:优点:效率高 缺点:空间占用大 拿空间换时间

带参宏传参的时候用”++”和”–”无法解决这个bug,C++用内联函数取代

3.效果:根据编译器觉得这个函数是函数最好还是宏最好

4.debug版本不会内联(为了调试),release才会内联

5.inline关键字一般写到函数实现中,函数实现简单才会被编译器内联

6.inline实现和声明要写一样

函数重载

  1. 来源于泛型(广泛)编程,主要解决类型问题
  2. 函数重载是多态的体现
  3. 调用的时候只要丢失精度或者类型不匹配可能构成二义性,如果直接写常量可以显示声明类型
  4. 重载函数一般不加默认参数,调用的时候没只有当前一个前类型的调用不到
  5. 重载构成条件
    1. 必须同作用域
    2. 函数名必须相同
    3. 返回值类型不当做重载依据
    4. 函数参数数量不同
    5. 个数相同,类型不同
    6. 个数相同,类型顺序不同
  6. 重载容易二义性的问题(标准没有规定,vs支持)
    1. TYPE&和type构造重载,只能传递const
    2. const TYPE*和TYPE *构造重载
    3. TYPE *const和TYPE *不够造重载
    4. const type和type不构造重载
    5. const TYPE和type不构造重载
    6. typedef不构成重载
  7. 构造重载看调用的时候能否区分

命名空间

  1. 关键字namespace
  2. 定义了一个作用域,namespace 作用域名
  3. 作用域名::指定作用域
  4. 如果不指定作用域会使用全局作用域
  5. using 作用域名有可能产生二义性
  6. C++默认产生一个std命名空间

Lambda表达式

  1. 解决了函数可以在函数内部实现
    1. [传递外部变量符号的方式](函数参数1,函数参数2..)->返回值类型

      {

      实现

      }

      auto my_add = lambda表达式; //定义函数指针

  2. 为了只让函数只在当前作用域内使用,其他函数使用不到
  3. 传递外部变量符号的方式可以只拷贝指定的变量,用“,”分隔变量,只写“=”全拷贝,为空则不拷贝
  4. 返回值写mutable表可以返回任意的类型

泛型编程设计

1. 函数不设计类型,使用void*,函数参数需要传递类型大小的值,函数指针给用户设置返回的指针类型

作业

  
/*
	编写程序,使用内联函数实现以下功能:
	1. 判断一个字符是否是数字
	2. 判断一个字符是否是字母
	3. 将一个字符转换大写
	4. 将一个字符转换小写
*/

inline bool isNumber(const char ch)
{
	if(ch >= '0' && ch <= '9')
	{
		return true;
	}
	else
	{
		return false;
	}
}

inline bool isAlphabet(const char ch)
{
	if((ch >= 'a' && ch <= 'z')
		||
		(ch >= 'A' && ch <= 'Z')
	)
	{
		return true;
	}
	else
	{
		return false;
	}
}

inline char alphabetToUpper(const char ch)
{
	if(ch >= 'a' && ch <= 'z')
	{
		return ch - 32;
	}
	else
	{
		return ch;
	}
}

inline char alphabetToLower(const char ch)
{
	if(ch >= 'A' && ch <= 'Z')
	{
		return ch + 32;
	}
	else
	{
		return ch;
	}
}

/*
	编写程序,使用内联函数实现以下功能,并使用函数重载使以下函数支持各种基本数据类型:
	5. 比较两数大小
	6. 求偶数
	7. 求闰年
	8. 求平方
	9. 求三角形的面积
	10.绝对值
*/

inline int cmpTwoNumberSize(const int num1, const int num2)
{
	if(num1 >= num2)
	{
		return num1;
	}
	else
	{
		return num2;
	}
}

inline char cmpTwoNumberSize(const char num1, const char num2)
{
	if(num1 >= num2)
	{
		return num1;
	}
	else
	{
		return num2;
	}
}

inline short cmpTwoNumberSize(const short num1, const short num2)
{
	if(num1 >= num2)
	{
		return num1;
	}
	else
	{
		return num2;
	}
}

inline double cmpTwoNumberSize(const double num1, const double num2)
{
	if(num1 >= num2)
	{
		return num1;
	}
	else
	{
		return num2;
	}
}

inline float cmpTwoNumberSize(const float num1, const float num2)
{
	if(num1 >= num2)
	{
		return num1;
	}
	else
	{
		return num2;
	}
}

inline bool isEvenNumber(const char num)
{
	if(num < 0)
	{
		return false;
	}
	else if(num == 0)
	{
		return true;
	}
	else
	{
		if(num % 2 == 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

inline bool isEvenNumber(const short num)
{
	if(num < 0)
	{
		return false;
	}
	else if(num == 0)
	{
		return true;
	}
	else
	{
		if(num % 2 == 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

inline bool isEvenNumber(const int num)
{
	if(num < 0)
	{
		return false;
	}
	else if(num == 0)
	{
		return true;
	}
	else
	{
		if(num % 2 == 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

inline bool isEvenNumber(const float num)
{
	if(num < 0)
	{
		return false;
	}
	else if(num == 0)
	{
		return true;
	}
	else
	{
		if(num % 2 == 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

inline bool isEvenNumber(const double num)
{
	if(num < 0)
	{
		return false;
	}
	else if(num == 0)
	{
		return true;
	}
	else
	{
		if(num % 2 == 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

inline bool isLeapYear(const char year)
{
	if(year < 4)
	{
		return false;
	}
	else
	{
		if(year % 400 == 0)
		{
			return true;
		}
		else if(year % 4 == 0 && year % 100 != 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

inline bool isLeapYear(const short year)
{
	if(year < 4)
	{
		return false;
	}
	else
	{
		if(year % 400 == 0)
		{
			return true;
		}
		else if(year % 4 == 0 && year % 100 != 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

inline bool isLeapYear(const int year)
{
	if(year < 4)
	{
		return false;
	}
	else
	{
		if(year % 400 == 0)
		{
			return true;
		}
		else if(year % 4 == 0 && year % 100 != 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

inline bool isLeapYear(const float year)
{
	if(year < 4)
	{
		return false;
	}
	else
	{
		if(year % 400 == 0)
		{
			return true;
		}
		else if(year % 4 == 0 && year % 100 != 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

inline bool isLeapYear(const double year)
{
	if(year < 4)
	{
		return false;
	}
	else
	{
		if(year % 400 == 0)
		{
			return true;
		}
		else if(year % 4 == 0 && year % 100 != 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

inline char getSquare(char num)
{
	return num * num;
}

inline short getSquare(short num)
{
	return num * num;
}

inline int getSquare(int num)
{
	return num * num;
}

inline float getSquare(float num)
{
	return num * num;
}

inline double getSquare(double num)
{
	return num * num;
}

inline char getTriangleArea(char a, char h)
{
	return a * h / 2;
}

inline short getTriangleArea(short a, short h)
{
	return a * h / 2;
}

inline int getTriangleArea(int a, int h)
{
	return a * h / 2;
}

inline float getTriangleArea(float a, float h)
{
	return a * h / 2;
}

inline double getTriangleArea(double a, double h)
{
	return a * h / 2;
}

inline char getAbs(char num)
{
	int i = a >> 31;  
    return ((a ^ i) - i);  
}

inline short getAbs(short num)
{
	int i = a >> 31;  
    return ((a ^ i) - i);  
}

inline int getAbs(int num)
{
	int i = a >> 31;  
    return ((a ^ i) - i);  
}

inline float getAbs(float num)
{
	int i = a >> 31;  
    return ((a ^ i) - i);  
}

inline double getAbs(double num)
{
	int i = a >> 31;  
    return ((a ^ i) - i);  
}
0 条评论
发表一条评论