C++基础入门

最新推荐文章于 2023-12-11 20:08:07 发布

m0_68993099

最新推荐文章于 2023-12-11 20:08:07 发布

阅读量231

点赞数 1

文章标签： c++ c语言

本文链接：https://blog.csdn.net/m0_68993099/article/details/124724380

版权

1.命名空间

2.c++的输入和输出

3.缺省参数

4.函数重载

5.引用

6.内联函数

一、命名空间

在c/c++中，变量、函数以及c++后面要学的类，都是大量存在的。它们的名称都存在全局作用域中，很可能会导致命名冲突。所以在c++中引入了命名空间的概念，来解决相应的问题，关键字：namespace。

1.命名空间的定义

//1.不同的命名空间中可以定义名称相同的变量和函数
namespace A  //A为这个明明空间的名称
{            //在命名空间中，不仅可以定义变量，也可以定义函数
	int a = 0;
	int b = 0;

	int ADD(int x, int y)
	{
		return x + y;
	}
}

namespace B
{
	int a = 0;
	int b = 0;

	int ADD(int x, int y)
	{
		return x + y;
	}
}

//2.命名空间也可以嵌套
namespace C
{
	int a = 0;
	int b = 0;

	int ADD(int x, int y)
	{
		return x + y;
	}
	namespace D
	{
		int a = 0;
		int b = 0;

		int ADD(int x, int y)
		{
			return x + y;
		}
	}
}

//3.在同一个工程中允许存在名称相同的命名空间，编译器会将它们合到一个空间中

一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

2.命名空间的使用

（1）加命名空间名称和作用域限定符

namespace A
{
	int a = 0;
	int b = 0;

	int ADD(int x, int y)
	{
		return x + y;
	}
}
int main()
{
	printf("%d", A::a); //A为空间名称  ::为作用域限定符  
}

（2）使用using将空间成员引入

namespace B
{
	int a = 0;
	int b = 0;

	int ADD(int x, int y)
	{
		return x + y;
	}
}
//使用using将变量b引入
using B::b;

int main()
{
	printf("%d", B::a); //a没有被引入 所以在这里只能使用方法（1）
	printf("%d", b);
}

（3）使用using namespace 命名空间名称引入

namespace B
{
	int a = 0;
	int b = 0;

	int ADD(int x, int y)
	{
		return x + y;
	}
}

using namespace B;

int main()
{
	printf("%d", a);
	printf("%d", b);

}

此方法有很大弊端，当使用using namespace 引入多个具有相同名称变量的命名空间时，会引起命名冲突。

//例
using namespace B;  //此处使用上面定义的两个命名空间
using namespace A;

int main()
{
	printf("%d", a);
	printf("%d", b);

}

会产生以下错误
在这里插入图片描述

二、c++的输入和输出

输入使用cin，输出使用cout ，必须包含< iostream >头文件以及std标准命名空

#include<iostream>
using namespace std;

1.使用C++输入输出更方便，不需增加数据格式控制，比如：整形–%d，字符–%c
cin和cout会自动识别变量的类型

#include<iostream>
using namespace std;

int main()
{
	int a = 0;
	double b = 0;
	char c =0;

	cin >> a;
	cin >> b >> c;

	cout << a<<endl;
	cout << b << " " << c << endl;
	return 0;
}

三、缺省参数

1.缺省参数的概念

缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。

//例
void fun(int x=10)
{
	cout << x << endl;
}

int main()
{
	fun();//没有传参，使用参数的默认值 10
	fun(1);//传参，使用指定的实参
	return 0;
}

结果
在这里插入图片描述

2.缺省参数的分类

（1）全缺省参数

顾名思义：定义函数时，所有的形参全部加上默认值

//例
void TestFunc(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

（2）半缺省参数

即形参一部分加上默认值，可以是一个也可以是多个

void TestFunc(int a , int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

注意：使用半缺省参数时要注意

半缺省参数必须从右往左依次来给出，不能间隔着给

//例
//正常使用
void TestFunc(int a, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

int main()
{
	TestFunc(1);
	TestFunc(1, 2);
	TestFunc(1, 2, 3);
	return 0;
}

//错误样例
void TestFunc(int a=10, int b , int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

int main()
{
	TestFunc(1);
	TestFunc(1, 2);
	TestFunc(1, 2, 3);
	return 0;
}
//会产生以下错误

在这里插入图片描述 2. 缺省参数不能在函数声明和定义中同时出现

//a.h  头文件声明
void TestFunc(int a = 10);
// a.cpp 源文件定义 
void TestFunc(int a = 20)
{}

如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。
3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）

四、函数重载

函数重载的概念

函数重载:是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。

int Add(int left, int right) 
{
	return left + right; 
}
double Add(double left, double right) 
{
	return left + right;
}
long Add(long left, long right) 
{
	return left + right;
}
int main()
{
	Add(10, 20);
	Add(10.0, 20.0);
	Add(10L, 20L);

	return 0;
}

五、引用

1.引用的概念

给已有的变量取一个别名，编译器不会为引用开品新的内存，变量和变量的引用共用一个内存空间。
类型& 引用变量名(对象名) = 引用实体；

//例
void TestRef()
{
	int a = 10;
	int& ra = a;//<====定义引用类型

	printf("%p\n", &a);
	printf("%p\n", &ra);
}

int main()
{
	TestRef();
	return 0;
}

结果 a和ra的地址相同
在这里插入图片描述

2.引用的特性

1.引用必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

//1.引用必须初始化
void TestRef()
{
	int& ra;//会报错
}

//2.一个变量可以有多个引用
void TestRef()
{
	int a = 0;
	int& b = a;
	int& c = a;
}

//3.引用一旦引用一个实体，再不能引用其他实体
void TestRef()
{
	int a = 10;
	int& ra = a;
	int b = 0;
	int& ra = b;//编译器会报错（“ra”: 重定义；多次初始化）
	printf("%p %p %p\n", &a, &ra);
}

3.常引用

int fun()
{
	const int a = 0;//const 修饰
	//int& b = a; //报错
	const int& b=a;//正确
}
int main()
{
	fun();
	return 0;
}

4.使用场景

（1）做参数

void swap(int& x,int& y)
{
	int tmp = x;
	x = y;
	y = x;
}

int main()
{
	int a = 10;
	int b = 0;
	swap(a,b);
	return 0;
}

（2）做返回值

int& add(int x, int y)//返回的是z的引用，
{
	int z = x + y;
	return z;
}

int main()
{
	int a = 10;
	int b = 20;
	int& ret=add(a, b);
	cout << ret << endl;//此行代码打印的是30
	cout << ret << endl;//此行代码打印的是随机值
	return 0;
}