【C++】C++对C的扩展

文章目录

【C++】C++对C的扩展
前言
一、设计一个类，求圆的周长
二、内联函数
三、函数的默认参数和占位参数
四、函数重载
[五、extern "C" 浅析](#五、extern "C" 浅析)
总结

前言

本篇文章将讲到在C++ 下如何设计一个类，内联函数，函数的默认参数和占位参数，函数重载， extern "C" 浅析。

一、设计一个类，求圆的周长

cpp 复制代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;



//设计一个类，求圆的周长

const double PI = 3.14;

//class + 类名
//周长公式 ：   2 * pi * m_R
class Circle
{
public: //公共权限

	//类中的函数  称为 成员函数  成员方法
	//求圆周长
	double calculateZC()
	{
		return 2 * PI * m_R;
	}

	//设置半径
	void setR(int r)
	{
		m_R = r;
	}

	//获取半径
	int getR()
	{
		return m_R;
	}


	//类中的变量   称为成员变量  成员属性
	//半径
	int m_R;

};

void test01()
{
	Circle  c1; //通过类 创建一个对象   实例化对象

	//给c1 半径赋值
	//c1.m_R = 10;
	c1.setR(10);


	//求c1圆周长
	cout << "圆的半径为： " << c1.getR() << endl;
	cout << "圆的周长为： " << c1.calculateZC() << endl;

}


int main() {
	test01();
	

	system("pause");
	return EXIT_SUCCESS;
}

二、内联函数

宏缺陷 ---引出内联函数

宏缺陷1 ：必须要加括号保证运算完整

宏缺陷2：即使加了括号，有些运算依然与预期不符

cpp 复制代码

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//宏缺陷1 ： 必须要加括号保证运算完整
#define  MYADD(x,y)  ((x) +(y))
void test01()
{
	int a = 10;
	int b = 20;
	int ret = MYADD(a, b) * 20;
	cout << ret << endl;
}

//宏缺陷2：  即使加了括号，有些运算依然与预期不符

#define MYCOMPARE(a,b)  (((a) < (b)) ? (a) : (b))

//普通函数 不会出现与预期结果不符的问题
void myCompare(int a, int b)
{
	int ret = a < b ? a : b;
	cout << "ret = " << ret << endl;
}

void test02()
{
	int a = 10;
	int b = 20;

	myCompare(++a, b);

	//int ret = MYCOMPARE(++a, b); //预期是 11 结果变为12   (((++a) < (b)) ? (++a) : (b))

	//cout << "ret = " << ret << endl;

}

在c++中，预定义宏的概念是用内联函数来实现的，而内联函数本身也是一个真正的函数。内联函数具有普通函数的所有行为。唯一不同之处在于内联函数会在适当的地方像预定义宏一样展开，所以不需要函数调用的开销。因此应该不使用宏，使用内联函数。

//内联函数

//函数的声明和实现必须同时加关键字 inline 才算内联函数

//内联函数好处：解决宏缺陷，本身是一个函数，带来宏优势，以空间换时间，在适当的时候做展开

inline void func();

inline void func() {};

//类内部的成员函数在函数前都隐式加了关键字 inline
但是c++内联编译会有一些限制，以下情况编译器可能考虑不会将函数进行内联编译：

不能存在任何形式的循环语句

不能存在过多的条件判断语句

函数体不能过于庞大

不能对函数进行取址操作

内联仅仅只是给编译器一个建议，编译器不一定会接受这种建议，如果你没有将函数声明为内联函数，那么编译器也可能将此函数做内联编译。一个好的编译器将会内联小的、简单的函数。

三、函数的默认参数和占位参数

默认参数语法形参类型变量 = 默认值

注意事项，如果有一个位置有了默认参数，那么从这个位置起，从左到右都必须有默认值

函数的声明和实现只能有一个提供默认参数，不可以同时加默认参数

占位参数只写一个类型进行占位，调用时候必须要传入占位值

cpp 复制代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;


//默认参数 语法  形参  类型 变量  = 默认值
//注意事项 ，如果有一个位置有了默认参数，那么从这个位置起，从左到右都必须有默认值
int func(int a, int b , int c = 10) 
{
	return a + b + c;
}

void test01()
{
	cout << func(20, 10) << endl;
}


//函数的声明和实现 只能有一个 提供默认参数，不可以同时加默认参数
void myFunc(int a = 10, int b = 10);
void myFunc(int a, int b) {};

//占位参数  只写一个类型进行占位，调用时候必须要传入占位值
//占位参数 用途？ 目前没用
void func2(int a, int = 1)
{

}

void test02()
{
	func2(10);
}


int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

四、函数重载

函数重载条件

1、在同一个作用域

2、函数名称相同

3、参数个数、类型、顺序不同

函数重载中引用两个版本

返回值不可以作为函数重载的条件

函数重载碰到默认参数注意避免二义性出现

cpp 复制代码

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//函数重载条件
//1、在同一个作用域
//2、函数名称相同
//3、参数个数、类型、顺序不同

//class Person
//{
//public:
//	void func()   成员函数 而不是全局函数
//	{
//	}
//};

void func()
{
	cout << "func()调用" << endl;
}

void func(int a)
{
	cout << "func(int a)调用" << endl;
}

void func(double a)
{
	cout << "func(double a)调用" << endl;
}

void func(int a, double b)
{
	cout << "func(int a ,double b)调用" << endl;
}

void func(double a, int b)
{
	cout << "func(double a, int b)调用" << endl;
}

//返回值可不可以作为函数重载的条件 答案：不可以
//int func(int a, double b)
//{
//	cout << "func(int a ,double b)调用" << endl;
//}



void test01()
{
	func(1, 3.14);
}



//函数重载中 引用两个版本
//void myFunc(int a)
//{
//	cout << "myfunc(int a )调用" << endl;
//}
void myFunc(int& a) // int & a  = 10;
{
	cout << "myfunc(int &a )调用" << endl;
}
void myFunc(const int& a) // const int &a = 10;
{
	cout << "myfunc( const int &a )调用" << endl;
}


void test02()
{
	int a = 10;
	//myFunc(a);//需要避免二义性出现

}


//函数重载碰到默认参数  注意避免二义性出现
void func2(int a, int b = 10)
{

}

void func2(int a)
{

}

void test03()
{
	//func2(10); //出现二义性
}


int main() {
	//test01();
	test02();

	system("pause");
	return EXIT_SUCCESS;
}

五、extern "C" 浅析

以下在Linux下测试:

c函数: void MyFunc(){} ,被编译成函数: MyFunc

c++函数: void MyFunc(){},被编译成函数: _Z6Myfuncv

通过这个测试，由于c++中需要支持函数重载，所以c和c++中对同一个函数经过编译后生成的函数名是不相同的，这就导致了一个问题，如果在c++中调用一个使用c语言编写模块中的某个函数，那么c++是根据c++的名称修饰方式来查找并链接这个函数，那么就会发生链接错误，以上例，c++中调用MyFunc函数，在链接阶段会去找Z6Myfuncv，结果是没有找到的，因为这个MyFunc函数是c语言编写的，生成的符号是MyFunc。

那么如果我想在c++调用c的函数怎么办？

extern "C"的主要作用就是为了实现c++代码能够调用其他c语言代码。加上extern "C"后，这部分代码编译器按c语言的方式进行编译和链接，而不是按c++的方式。

test.h

c 复制代码

#ifdef __cplusplus  // 两个下划线  __  c plus plus
extern "C" {
#endif

#include <stdio.h>

	void show();


#ifdef __cplusplus
}
#endif

test.c

c 复制代码

#include "test.h"

void show()
{
	printf("hello world\n");
}

extern "C"浅析.cpp

cpp 复制代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include "test.h"


//告诉编译器  show函数用C语言方式 做链接
//extern "C" void show();

void test01()
{
	show();//_Z4showv;在C++中有函数重载会修饰函数名，但是show是c语言文件，因此链接失败
}

int main() {
	test01();


	system("pause");
	return EXIT_SUCCESS;
}

总结

到这里这篇文章的内容就结束了，谢谢大家的观看，如果有好的建议可以留言喔，谢谢大家啦！