C++入门(1)

1. C++关键字(C++98)

C++ 总计 63 个关键字, C 语言 32 个关键字
ps :下面我们只是看一下 C++ 有多少关键字,不对关键字进行具体的讲解。后面我们学到以后再
细讲。


**2.**命名空间

在C/C++中,变量、函数和后面要学到的类都是大量存在的,这些变量、函数和类的名称将都存 在于全局作用域中,可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化, 以避免命名冲突或名字污染,namespace关键字的出现就是针对这种问题的。先使用c语言来给大家解释一下,由于头文件stdlib.h里面有一个rand函数,但是我们又定义了一个全局变量rand,此时我们想打印的话就会报错,因为重定义了。所以C++提出了命名空间来解决这个问题。

cpp 复制代码
#define _CRT_SECURE_NO_WARNINGS 1

#include<stdlib.h>
#include<stdio.h>
int rand = 10;

int main()
{
	printf("%d ", rand);
	return 0;
}

2.1****命名空间定义

定义命名空间,需要使用到namespace****关键字,后面跟命名空间的名字,然**后接一对****{}**即可,{} 中即为命名空间的成员。

如果在命名空间zxf里面定义一个rand,此时再去打印rand,结果就是rand函数的地址,那么如何打印zxf里面的rand呢?

下面这种方式就可以访问到命名空间内部的东西。

cpp 复制代码
//1. 正常的命名空间定义
namespace zxf 
{
	int	rand = 1;
}

int main()
{
	printf("%d ",zxf::rand);
	return 0;
}
cpp 复制代码
//1. 正常的命名空间定义
namespace zxf 
{
	int	rand = 1;
	int Add(int a, int b)
	{
		return a + b;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

int main()
{
	printf("%d ",zxf::rand);
	zxf::Add(1, 4);
	struct zxf::Node node;

	return 0;
}

命名空间还可以嵌套定义,实现无限套娃。

cpp 复制代码
//2. 命名空间可以嵌套
namespace zxf 
{
	namespace zxf1
	{
		int rand = 1;
	}
	namespace zxf2
	{
		int rand = 2;
	}
	int	rand = 0;
	int Add(int a, int b)
	{
		return a + b;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

int main()
{
	printf("%d ",zxf::rand);
	zxf::Add(1, 4);
	struct zxf::Node node;
	printf("%d ", zxf::zxf1::rand);
	printf("%d ", zxf::zxf2::rand);
	return 0;
}

同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。

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

2.2****命名空间使用

命名空间中成员该如何使用呢?比如:

cpp 复制代码
namespace zxf
{
	// 命名空间中可以定义变量/函数/类型
	int a = 0;
	int b = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}
int main()
{
	// 编译报错:error C2065: "a": 未声明的标识符
	printf("%d\n", a);
	return 0;
}

命名空间的使用有三种方式:
加命名空间名称及作用域限定符:

cpp 复制代码
int main()
{
	printf("%d\n", zxf::a);
	return 0;
}

使用 using 将命名空间中某个成员引入:

cpp 复制代码
using zxf::b;
int main()
{
	printf("%d\n", zxf::a);
	printf("%d\n", b);
	return 0;
}

使用 using namespace 命名空间名称 引入:

cpp 复制代码
using namespce zxf;
int main()
{
	printf("%d\n", zxf::a);
	printf("%d\n", b);
	Add(10, 20);
	return 0;
}

**3. C++输入&**输出

C++ 刚出来后,也算是一个新事物。
那 C++ 是否也应该向这个美好的世界来声问候呢?我们来看下 C++ 是如何来实现问候的。

cpp 复制代码
#include<iostream>
// std是C++标准库的命名空间名,C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
	cout << "Hello world!!!" << endl;
	return 0;
}

说明:

  1. 使用 cout 标准输出对象 ( 控制台 )cin 标准输入对象 ( 键盘 ) 时,必须 包含 < iostream > 头文件以及按命名空间使用方法使用std 。
  2. cout 和 cin 是全局的流对象, endl 是特殊的 C++ 符号,表示换行输出,他们都包含在包含 <
    iostream > 头文件中。
  3. << 是流插入运算符, >> 是流提取运算符
  4. 使用 C++ 输入输出更方便,不需要像 printf/scanf 输入输出时那样,需要手动控制格式。
    C++ 的输入输出可以自动识别变量类型
  5. 实际上 cout 和 cin 分别是 ostream 和 istream 类型的对象, >> 和 << 也涉及运算符重载等知识,
    这些知识我们我们后续才会学习,所以我们这里只是简单学习他们的使用。后面我们还有有
    一个章节更深入的学习 IO 流用法及原理。
    注意:早期标准库将所有功能在全局域中实现,声明在 .h 后缀的头文件中,使用时只需包含对应
    头文件即可,后来将其实现在 std 命名空间下,为了和 C 头文件区分,也为了正确使用命名空间,
    规定 C++ 头文件不带 .h ;旧编译器 (vc 6.0) 中还支持 <iostream.h> 格式,后续编译器已不支持,因
    推荐 使用 <iostream>+std 的方式。
cpp 复制代码
#include <iostream>
using namespace std;
int main()
{
	int a;
	double b;
	char c;

	// 可以自动识别变量的类型
	cin >> a;
	cin >> b >> c;

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

std 命名空间的使用惯例:
std 是 C++ 标准库的命名空间,如何展开 std 使用更合理呢?

  1. 在日常练习中,建议直接 using namespace std 即可,这样就很方便。
  2. using namespace std 展开,标准库就全部暴露出来了,如果我们定义跟库重名的类型 / 对
    象 / 函数,就存在冲突问题。该问题在日常练习中很少出现,但是项目开发中代码较多、规模
    大,就很容易出现。所以建议在项目开发中使用,像 std::cout 这样使用时指定命名空间 +
    using std::cout 展开常用的库对象 / 类型等方式。

**4.**缺省参数

4.1****缺省参数概念

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

下面Func就是一个缺省参数,第一次调用没有传参,那么就使用1这个缺省值,第二次调用有实参10,所以忽略缺省值,使用实参10.

cpp 复制代码
#include <iostream>
using namespace std;
void Func(int i = 1)
{
	cout << i << endl;
}
int main()
{
	Func();
	Func(10);
	return 0;
}

4.2****缺省参数分类

全缺省参数

全缺省就是此函数的参数都设置了缺省值,所以我们可以根据自己的需求传参。

cpp 复制代码
void Func(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
int main()
{
	Func();
	Func(100);
	Func(100,200);
	Func(100, 200,300);
	return 0;
}

半缺省参数

半缺省就是缺省一部分的参数。

cpp 复制代码
void Func(int a, int b = 10, int c = 20)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
int main()
{
	//Func();
	Func(100);
	Func(100,200);
	Func(100, 200,300);
	return 0;
}

注意:

  1. 半缺省参数必须 从右往左依次 来给出,不能间隔着给
    为什么呢?因为从左往右给缺省参数是会有歧义的,比如c不给缺省参数,那么实参是给a和b,还是b和c呢?这就不确定了。
  2. 缺省参数不能在函数声明和定义中同时出现

最好的方式是声明给缺省参数,定义不给。

cpp 复制代码
  //a.h
void Func(int a = 10);

// a.cpp
void Func(int a = 20)
{}

// 注意:如果生命与定义位置同时出现,恰巧两个位置提供的值不同,那编译器就无法确定到底该
用那个缺省值。
  1. 缺省值必须是常量或者全局变量
  2. C 语言不支持(编译器不支持)

**5.**函数重载

自然语言中,一个词可以有多重含义,人们可以通过上下文来判断该词真实的含义,即该词被重
载了。
比如:以前有一个笑话,国有两个体育项目大家根本不用看,也不用担心。一个是乒乓球,一个
是男足。前者是 " 谁也赢不了! " ,后者是 " 谁也赢不了!"

5.1****函数重载概念

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

下面两个Add函数虽然名称是一样的,但是调用的时候编译器会自动匹配,因为两个同名函数构成了函数重载。那么如果一个参数是int,另一个是double呢?如果这样做编译器会报错,因为虽然可以进行隐式类型转换,但是到底是double转int呢,还是int转double呢?

cpp 复制代码
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;

	return left + right;
}

double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;

	return left + right;
}

int main()
{
	Add(1, 3);
	Add(1.1, 2.2);
	return 0;
}

下面这两个函数也构成重载,因为参数个数不同。

cpp 复制代码
void f()
{
	cout << "f()" << endl;
}
void f(int a)
{
	cout << "f(int a)" << endl;
}
int main()
{
	f();
	f(20);

	return 0;
}

但是当第二个f给了缺省参数时,就会存在二义性。

cpp 复制代码
void f()
{
	cout << "f()" << endl;
}
void f(int a=0)
{
	cout << "f(int a)" << endl;
}
int main()
{
	f();
	f(20);

	return 0;
}

下面两个函数构成重载的原因是参数类型顺序不同。

**6.**引用

6.1****引用概念

引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空 间,它和它引用的变量共用同一块内存空间。

类型**&引用变量名(对象名) =**引用实体;

通过下面一段代码我们可以知道如果c++的话会影响a。因为c就是a,但是b就不会。

当然还可以给c取一个别名d,d的变化也会影响a,一个变量可以取多个别名。并且它们的地址是一样的。

注意:引用类型必须和引用实体同种类型的。

6.2****引用特性

  1. 引用在定义时必须初始化

  2. 一个变量可以有多个引用

  3. 引用一旦引用一个实体,再不能引用其他实体

6.3****常引用

cpp 复制代码
void TestConstRef()
{
	const int a = 10;
	//int& ra = a;   // 该语句编译时会出错,a为常量
	const int& ra = a;
	// int& b = 10; // 该语句编译时会出错,b为常量
	const int& b = 10;
	double d = 12.34;
	//int& rd = d; // 该语句编译时会出错,类型不同
	const int& rd = d;
}

6.4****使用场景

  1. 做参数
    在学习引用之后交换两个变量就不需要传地址了,形参使用引用接收就行了,left就是a的别名,right就是b的别名。
    并且引用做参数也能提高效率。

  2. 做返回值

注意看下面这段代码,第二次打印ret的值是7或者是随机值,随机值是取决于编译器会不会清理掉Add的栈帧,如果清理了的话第一次和第二次打印都是随机值,如果没有清理,第一次是3,第二次是7,因为是同一个函数,使用的是同一块空间,并且返回值是引用,那么经过第一次调用ret就是c,第二次会修改掉c,那么就会改变ret。


注意: 如果函数返回时,出了函数作用域,如果返回对象还在 ( 还没还给系统 ) ,则可以使用
引用返回,如果已经还给系统了,则必须使用传值返回。

6.5****引用和指针的区别

语法概念上 引用就是一个别名,没有独立空间,和其引用实体共用同一块空间。
底层实现上 实际是有空间的,因为 引用是按照指针方式来实现 的。
引用和指针的不同点 :

  1. 引用概念上定义一个变量的别名,指针存储一个变量地址。
  2. 引用 在定义时 必须初始化 ,指针没有要求
  3. 引用 在初始化时引用一个实体后,就 不能再引用其他实体 ,而指针可以在任何时候指向任何 一个同类型实体
  4. 没有 NULL 引用 ,但有 NULL 指针
  5. sizeof 中含义不同引用 结果为 引用类型的大小 ,但 指针 始终是 地址空间所占字节个数 (32 位平台下占4 个字节 )
  6. 引用自加即引用的实体增加 1 ,指针自加即指针向后偏移一个类型的大小
  7. 有多级指针,但是没有多级引用
  8. 访问实体方式不同, 指针需要显式解引用,引用编译器自己处理
  9. 引用比指针使用起来相对更安全

今天的分享到这里就结束了,感谢大家的阅读!

相关推荐
Charles Ray几秒前
C++学习笔记 —— 内存分配 new
c++·笔记·学习
重生之我在20年代敲代码几秒前
strncpy函数的使用和模拟实现
c语言·开发语言·c++·经验分享·笔记
爱上语文2 分钟前
Springboot的三层架构
java·开发语言·spring boot·后端·spring
我要吐泡泡了哦1 小时前
GAMES104:15 游戏引擎的玩法系统基础-学习笔记
笔记·学习·游戏引擎
骑鱼过海的猫1231 小时前
【tomcat】tomcat学习笔记
笔记·学习·tomcat
编程零零七2 小时前
Python数据分析工具(三):pymssql的用法
开发语言·前端·数据库·python·oracle·数据分析·pymssql
贾saisai3 小时前
Xilinx系FPGA学习笔记(九)DDR3学习
笔记·学习·fpga开发
北岛寒沫3 小时前
JavaScript(JS)学习笔记 1(简单介绍 注释和输入输出语句 变量 数据类型 运算符 流程控制 数组)
javascript·笔记·学习
2401_858286113 小时前
52.【C语言】 字符函数和字符串函数(strcat函数)
c语言·开发语言
铁松溜达py3 小时前
编译器/工具链环境:GCC vs LLVM/Clang,MSVCRT vs UCRT
开发语言·网络