C++_内联函数，默认参数，函数占位参数，函数重载，函数重载和函数指针结合,struct和class关键字区别，类的定义和类的实现分开写，面向过程向面向对象的转变

最新推荐文章于 2023-01-14 12:55:11 发布

Mr_WangAndy

最新推荐文章于 2023-01-14 12:55:11 发布

阅读量136

点赞数

分类专栏： C++ 文章标签：内联函数占位参数 struct和class

本文链接：https://blog.csdn.net/weixin_43916755/article/details/88085184

版权

C++ 专栏收录该内容

53 篇文章 4 订阅

订阅专栏

      主要记录了：内联函数，默认参数，函数占位参数，函数重载，函数重载和函数指针结合,struct和class关键字区别，类的定义和类的实现分开写，面向过程向面向对象的转变

内联函数

内敛函数的说明(这个我没弄懂)
说明1：

必须inline int myfunc(int a, int b)和函数体的实现，写在一块

说明2

C++编译器可以将一个函数进行内联编译
被C++编译器内联编译的函数叫做内联函数
内联函数在最终生成的代码中是没有定义的
C++编译器直接将函数体插入在函数调用的地方
内联函数没有普通函数调用时的额外开销(压栈，跳转，返回)

说明3：C++编译器不一定准许函数的内联请求！
说明4

内联函数是一种特殊的函数，具有普通函数的特征（参数检查，返回类型等）
内联函数是对编译器的一种请求，因此编译器可能拒绝这种请求
内联函数由编译器处理，直接将编译后的函数体插入调用的地方
宏代码片段由预处理器处理，进行简单的文本替换，没有任何编译过程
说明5：
现代C++编译器能够进行编译优化，因此一些函数即使没有inline声明，也可能被编译器内联编译
另外，一些现代C++编译器提供了扩展语法，能够对函数进行强制内联
如：g++中的__attribute__((always_inline))属性
说明6：
C++中内联编译的限制：
不能存在任何形式的循环语句
不能存在过多的条件判断语句
函数体不能过于庞大
不能对函数进行取址操作
函数内联声明必须在调用语句之前
编译器对于内联函数的限制并不是绝对的，内联函数相对于普通函数的优势只是省去了函数调用时压栈，跳转和返回的开销。
因此，当函数体的执行开销远大于压栈，跳转和返回所用的开销时，那么内联将无意义。
结论：
1）内联函数在编译时直接将函数体插入函数调用的地方
2）inline只是一种请求，编译器不一定允许这种请求
3）内联函数省去了普通函数调用时压栈，跳转和返回的开销

宏的例子：
#define MYFUNC(a,b) (a<b?a:b)
int main()
{
//printA();

int a = 1;
int b = 3;
int c = MYFUNC(++a, b);
cout << a << endl;
cout << b << endl;
cout << c << endl;

system("pause");
return 1;

}// 执行结果 a=3,b=3,c=3

默认参数

/*1
C++中可以在函数声明时为参数提供一个默认值，
当函数调用时没有指定这个参数的值，编译器会自动用默认值代替
例子：
void myPrint(int x = 3)
{
printf(“x:%d”, x);
}
int main()
{
myPrint(2);
myPrint(); //两个都能编译通过。

}
//在默认参数规则，如果默认参数出现，那么右边的都必须有默认参数
void printABC(int a, int b, int x = 3, int y=4, int z = 5)
{
printf(“x:%d\n”, x);
}

函数占位参数

函数占位参数
占位参数只有参数类型声明，而没有参数名声明
一般情况下，在函数体内部无法使用占位参数
void fun(int a,int b,int =0)
{
cout << a << b << endl;

}

int main()
{
//printA();
fun(1, 2, 4);
system(“pause”);
return 1;
}

函数重载

1 函数重载概念
函数重载(Function Overload)
用同一个函数名定义不同的函数
当函数名和不同的参数搭配时函数的含义不同
2 函数重载的判断标准
/*
函数重载至少满足下面的一个条件：
参数个数不同
参数类型不同
参数顺序不同
*/
3 函数返回值不是函数重载的判断标准
例子：

void fun(int a,int b,int =0)
{
cout << a << b << endl;
}
void fun1(int a)
{
cout << a << endl;
}
void fun2(int *a)
{
cout << a << endl;
}
void fun3(int a,int b)
{
cout << a << b<<endl;
}
上面属于函数重载。

函数重载和函数指针结合

void fun1(int a,int b)
{
cout << a << b<<endl;
}

//函数指针的基础语法
typedef void (myTypeFun)(int a, int b);//自定义数据类型
typedef void (*mytTypeFun)(int a, int b);//自定义数据类型
// 函数指针，
//声明一个函数类型
//声明一个函数指针类型
//声明一个函数类型
int main()
{
//printA();
myTypeFun *t = NULL; //定义一个数据类型，指向函数入口地址。
// mytTypeFun t = NULL;
t = fun1;
t(1, 2); //输出 1,2
system(“pause”);
return 1;
}

后面讲（函数重载、重写、重定义）

重载是一个面试频率很高的知识点。

C++应该站在什么视角看待问题—学习C++的技术路线

站在编译器的角度看待类和对象。
上面有具体的学习路线。

类和对象

封装的含义
封装有两层含义：
A 把数据（属性）和函数（操作）合成一个整体，这在计算机世界中是用类与对象实现的。
class MyClass
{
public:
double m_r;
double m_s;
public:

void set(double r)
{
	m_r = r;
}
double getR()
{
	return m_r;
}
double getS()
{
	return 3.14*m_r*m_r;
}

};
//类封装了成员变量和成员函数。
void printClass01(MyClass *pc)
{
cout << pc->getR() << endl;
cout << pc->getS() << endl;
}
void printClass02(MyClass &pc)
{

}
void printClass03(MyClass pc)
{

}
int main()
{

MyClass c1;
c1.set(10);
//c1.getR();
//cout << c1.getS() << endl;
printClass01(&c1);

system("pause");
return 1;

}
上面例子，功能强大的地方在于，void printClass01(MyClass *pc)，可以访问类中所有的public中的属性和方法。
B）封装，把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。（访问控制）
类的内部和类的外部：
如果类的属性是私有的，则在类的外部不能访问。

struct和class关键字区别：

在用struct定义类时，所有成员的默认属性为public
在用class定义类时，所有成员的默认属性为private

例子代码：
struct AAA
{
int a;
};
int main()
{
AAA a1; // 可以
a1.a;// 可以访问属性a。
system(“pause”);
return 1;
}

类的定义和类的实现分开写：

在MyTeacher.h中声明类的属性和功能，在.cpp中实现类的功能，在另一个文件中包含.h，然后使用。
代码如下：

MyTeacher.h

#pragma once //这句话意思是只包含一次。
class MyTeacher
{
public:
int m_age;

char name[32];

public:
void setAge(int age);
int getAge();
};

MyTeacher.cpp
#include “MyTeacher.h”

void MyTeacher::setAge(int age)
{
m_age = age;
}
int MyTeacher::getAge()
{
return m_age;
}

源.cpp
#include
#include “MyTeacher.h” //包含.h文件.
using namespace std;
int main()
{
MyTeacher t1;
t1.setAge(36);
cout << t1.getAge() << endl;
system(“pause”);
return 1;
}

面向过程向面向对象的转变

实例：求一个立方体的面积和体积。
代码：
class Cube
{
public:
void setA(int a)
{
m_a = a;
}
void setB(int b)
{
m_b = b;
}
void setC(int c)
{
m_c = c;
}
void setABC(int a = 0, int b = 0, int c = 0)
{
m_a = a;
m_b = b;
m_c = c;
}
public:
int getV()
{
m_v = m_am_bm_c;
return m_v;
}
int getS()
{
m_s = 2 * (m_am_b + m_am_c + m_c*m_b);
return m_s;
}
private:
int m_a, m_b, m_c;
int m_s;
int m_v;
};
int main()
{
Cube cu;
cu.setABC(1, 2, 3);
cout << cu.getS() << endl;
cout << cu.getV() << endl;

system("pause");
return 1;

}
实例2：判断两个立方体体积是否相等（按照，三条边相等方法进行判断）
立方体是否相等
方法1:全局变量法。
class Cube
{
public:
void setA(int a)
{
m_a = a;
}
void setB(int b)
{
m_b = b;
}
void setC(int c)
{
m_c = c;
}
void setABC(int a = 0, int b = 0, int c = 0)
{
m_a = a;
m_b = b;
m_c = c;
}
public:
int getV()
{
m_v = m_am_bm_c;
return m_v;
}
int getS()
{
m_s = 2 * (m_am_b + m_am_c + m_c*m_b);
return m_s;
}
int getA()
{
return m_a;
}
int getB()
{
return m_b;
}
int getC()
{
return m_c;
}

private:
int m_a, m_b, m_c;
int m_s;
int m_v;
};
//全局函数方法：用引用的方式。
int judgeCube(Cube &v1,Cube &v2)
{
if(v1.getA()==v2.getA()&& v1.getB() == v2.getB() && v1.getC() == v2.getC())
return 1;
else
{
return 0;
}
}

int main()
{
Cube v1, v2;
v1.setABC(1, 2, 3);
v2.setABC(1, 2, 5);
cout << v1.getS() << endl;
cout << v1.getV() << endl;
if (judgeCube(v1, v2) == 1)
{
cout << “两个正方体相等” << endl;
}
else
{
cout << “两个正方体不相等” << endl;
}
system(“pause”);
return 1;
}
方法2：把上面的全局函数judgeCube（）变成类的成员函数，
代码如下：
class Cube
{
public:
void setA(int a)
{
m_a = a;
}
void setB(int b)
{
m_b = b;
}
void setC(int c)
{
m_c = c;
}
void setABC(int a = 0, int b = 0, int c = 0)
{
m_a = a;
m_b = b;
m_c = c;
}
public:
int getV()
{
m_v = m_am_bm_c;
return m_v;
}
int getS()
{
m_s = 2 * (m_am_b + m_am_c + m_c*m_b);
return m_s;
}
int getA()
{
return m_a;
}
int getB()
{
return m_b;
}
int getC()
{
return m_c;
}

int judgeCube(Cube &v1, Cube &v2)
{
	if (v1.getA() == v2.getA() && v1.getB() == v2.getB() && v1.getC() == v2.getC())
		return 1;
	else
	{
		return 0;
	}
}

private:
int m_a, m_b, m_c;
int m_s;
int m_v;
};

int main()
{
Cube v1, v2;
v1.setABC(1, 2, 3);
v2.setABC(1, 2, 5);
cout << v1.getS() << endl;
cout << v1.getV() << endl;
if (v2.judgeCube(v1,v2)== 1)
{
cout << “两个正方体相等” << endl;
}
else
{
cout << “两个正方体不相等” << endl;
}
system(“pause”);
return 1;
}
方法3，纯面向对象的方法求解这个问题：
class Cube
{
public:
void setA(int a)
{
m_a = a;
}
void setB(int b)
{
m_b = b;
}
void setC(int c)
{
m_c = c;
}
void setABC(int a = 0, int b = 0, int c = 0)
{
m_a = a;
m_b = b;
m_c = c;
}
public:
int getV()
{
m_v = m_am_bm_c;
return m_v;
}
int getS()
{
m_s = 2 * (m_am_b + m_am_c + m_c*m_b);
return m_s;
}
int getA()
{
return m_a;
}
int getB()
{
return m_b;
}
int getC()
{
return m_c;
}

int judgeCube(Cube &v1, Cube &v2)
{
	if (v1.getA() == v2.getA() && v1.getB() == v2.getB() && v1.getC() == v2.getC())
		return 1;
	else
	{
		return 0;
	}
}
int judgeCube(Cube &v2)  //在这个基础之上m_a就是v1的。
{
	if (m_a == v2.getA()
		&& m_b == v2.getB()
		&& m_c == v2.getC()
		)
		return 1;
	else
		return 0;
}

private:
int m_a, m_b, m_c;
int m_s;
int m_v;
};
int main()
{
Cube v1, v2;
v1.setABC(1, 2, 3);
v2.setABC(1, 2, 5);
cout << v1.getS() << endl;
cout << v1.getV() << endl;
if (v2.judgeCube(v1,v2)== 1)
{
cout << “两个正方体相等” << endl;
}
else
{
cout << “两个正方体不相等” << endl;
}
if (v1.judgeCube(v2) == 1)
{
cout << “两个正方体相等” << endl;
}
else
{
cout << “两个正方体不相等” << endl;
}
system(“pause”);
return 1;
}

Mr_WangAndy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++_内联函数，默认参数，函数占位参数，函数重载，函数重载和函数指针结合,struct和class关键字区别，类的定义和类的实现分开写，面向过程向面向对象的转变

内联函数内敛函数的说明(这个我没弄懂)说明1：必须inline int myfunc(int a, int b)和函数体的实现，写在一块说明2C++编译器可以将一个函数进行内联编译被C++编译器内联编译的函数叫做内联函数内联函数在最终生成的代码中是没有定义的C++编译器直接将函数体插入在函数调用的地方内联函数没有普通函数调用时的额外开销(压栈，跳转，返回)说明3：C...
复制链接

扫一扫