c++入门知识点

系列文章目录

本章节将带领大家共同学习c++的入门知识点，为后续的学习做好铺垫

  Hello world

接下来我将按照从上往下的顺序进行讲解：

1、命名空间域 

2、c和c++的输入与输出差距

3、缺省参数

四、函数重载

五、引用

---

---

提示：以下是本篇文章正文内容，下面案例可供参考

#  Hello world

#include<iostream>
    int main()
{
using namespace std::cout;
using namespace std::endl;

    std::cout << "Hello word"<<std::endl;

    cout<<"Hello word"<<endl;
    return 0;
}

接下来我将按照从上往下的顺序进行讲解：

1、iostream 是c++中标准库中的头文件，里面包含了标准输出、标准输入、类和对象。

2、using namespace 。域：全局域、局部域、命名空间域、类域。

2、std：：cout  ，std：：endl； std全称为standard，用于命名空间中

3、<<  则是流输入，理解为将左边的数据通过左移插入到流中。

以上为全文简介，接下来将通过代码的形式将内容更好的呈现出来。

1、命名空间域 

当多人撰写不同的代码模块时，可能会出现编写的变量、函数、类型名重复，导致代码显示重定义。为了避免这种情况，我们使用 namespace 将重复的变量定义在不同的域中，这样变量与变量之间就存在一个分割线互不打扰。

书写格式： namespace + 名字 + {  }

#include<iostream>

namespace slo
{
	int a = 10;
}

int main()
{
int a =20;
	printf("%d\n", a);//c语言

	std::cout << slo::a << std::endl;//c++打印

	return 0;
}

1.2 空间的访问顺序

局部变量（包含函数内部的局部变量）、全局变量、命名空间域内部的变量。

 

C语言：

• 类比于一个单间（studio apartment），所有东西都放在一个房间里。这个房间只有一个公共空间，所有变量和函数都放在同一个空间中。
• 由于只有一个空间，当出现两个相同的函数或者变量时，容易发生冲突和混乱。

C++中的命名空间：

• 类比于一个套二的公寓（two-bedroom apartment），有两个独立的房间（命名空间），两个空间内分别可以定义相同的函数和变量。
• 正是因为函数和变量之间都有独立的空间，就需要独立的访问方式。（作用域解析运算符 ::），以便进入特定的房间并使用其中的成员变量。
• 这样，即使两个不同的人有不同的装修理念，他们也不会相互干扰，因为他们在不同的房间里工作。

c++中的命名空间简化：

using则可以引用命名空间域的名称，从而简化每次撰写代码时加上完整的命名空间名字。

#include <iostream>

using namespace std;


int a = 30; // 全局变量，相当于公共空间中的变量

namespace LRoom {
    int a = 10; // leftRoom 中的变量，相当于左房间中的变量
}

namespace rRoom {
    int a = 20; // RightRoom 中的变量，相当于右房间中的变量
}

int main() {
    // 使用作用域解析运算符访问不同命名空间中的变量
    std::cout << "全局变量 a: " << ::a << std::endl;           // 打印全局变量 a
    std::cout << "LRoom 中的变量 a: " << LRoom::a << std::endl; // 打印 LRoom 中的变量 a
    std::cout << "rRoom 中的变量 a: " << rRoom::a << std::endl; // 打印 rRoomB 中的变量 a
   using写法：    cout << "rRoom 中的变量 a: " << rRoom::a << endl; 

    return 0;
}

2、c和c++的输入与输出差距

int main()
{
	int i = 0;
	std::cout << i<<"\n";
	printf("%d", i);

	char  arr[10] = { 0 };
	std::cin >> arr;
	scanf_s("%c", &arr);
	std::cout << arr;
	return 0;
}

2.1 c++输出、输入

 示例    ： std::cout<<  变量 <<std::endl;  endl为换行符

示例     ：std::cin>>变量;

2.2 流的提取与插入 

 << 流插入 

>>  流提取（流输入）

2.3 使用输入与输出需包含头文件

c++的头文件：#include<iostream>内部包含了标准的输出流（std：：cout）、标准输出流（std：：cin）。

后期会讲述cout与cin内部的实现过程，现在只需要明白内部是通过函数进行调用。

ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
这三行代码则是让程序在调用cout、cin等函数时能减少时间的开销。

3、缺省参数

在c语言中函数传参，是由实参决定传入多少数据，形参负责接受参数。

在c++中则是可以通过形参对内部的变量进行赋值，这种赋值的操作称之为“缺省参数”，若实参内部共传入3个值，形参只赋值一般则称之为“半缺省参数”。

3.1 注意事项

1、若函数既有声明与定义，此时缺省参数只能出现在函数声明中。

// 在函数声明中定义缺省参数
void func(int a=10;int b=20);

int main() {
    // 调用函数时省略了缺省参数
    func();                   // 使用所有缺省参数
    func("20");               // 使用部分缺省参数
    printMessage(3,-1);       // 不使用缺省参数

    return 0;
}

// 在函数定义中不需要再次提供缺省参数
void printMessage(int a, int b) 
    
  

2、缺省参数需遵守从右向左的方式进行初始化，不得出现中间参数没有参数、或者左右俩边存在

// 错误示例：中间参数没有缺省，而右侧参数缺省
void func(int a = 1, int b, int c = 3);

四、函数重载

4.1  函数重载简介：支持俩个函数名相等，但是内部的参数因顺序、个数、类型不一致。

4.2 函数重载代码实现

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


double Add(double x, double y)
{
	return x + y;
}

//函数名相等，但是顺序或者类型不一致

4.3 函数形参不一致

void z(int x,char c)
{
	std::cout << "z(int x,char c)" << std::endl;
}

void z(char x,int c)
{
	std::cout << "z(char x,int c)" << std::endl;
}

int main()
{
	z(1, 'x');

	z('x', 1);

	return 0;
}

五、引用

5.1 引用的概念

c++在设计之初，为了尽可能方便使用会采用大量相同类型的运算符，引用则是取自于c语言中的&取地址操作，通过对相同内存的地址进行命名操作。

  类型 & 别名 = 被修改对象

int main()
{
	using std::cout;
	using std::endl;

	int a = 10;

	int& b = a;

	int& c = b;

	int& d = c;

	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &d << endl;
}
总结：引用就是对地址取别名，比如：张三、三哥、三弟都是一个人	
0000009BBC0FFC14
0000009BBC0FFC14
0000009BBC0FFC14
0000009BBC0FFC14

5.2  引用规则：

1、引用必须初始化，且绑定一个有效的对象（不得绑定为空）

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

2、一个引用对象可以产生多个引用别名

3、只能引用一个实体变量

int a =10;

int c= 20;

int &b = a;

int &b = c;

5.3 引用传参：

既然引用调用的是原本的变量，那是否可以将指针的传址改成引用？

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

void swap(int& x, int& y)
{
    int tmp = x;
    x = y;
    y = tmp;
}
int main()
{
    int a = 10;
    int b = 20;
    swap(&a, &b);//俩种结果均实现了交换
    swap(a, b);//
}

此时，屏幕前的靓仔是不是产生了一个念想，既然C++中引用能够实现指针传址的功能，那两者是否可以理解为等价？

先说结论，不可以！

假设条件：a的指向为b，若要修改a的最初指向？

指针实现:

1、将*b置为NULL。

2、将a指向c即可。

引用实现：

则无法修改指向。b内部存储的还是a的地址，若置为空则会将a的地址也会置为空，且引用必须初始化，且必须具备一个有效对象。

总结：

1、引用在实践中主要用于传参和引用做返回值中，减少拷贝提高效率和改变被引用对象名称。

2、指针很容易出现空指针和野指针的问题，引⽤则使⽤起来相对更安全⼀些。

3、引用可以直接访问对象，指针则需要通过解引用访问对象。

4、指针可以修改指向，引用则不可以。

const 引用

int main( )
{
const int a =10;

int &ra = a;// 权限被放大
解释：关键点在于int &ra，const是常量，引用则削减了const。所以这是权限放大。
修改：const int &ra = a；

int b = 20；
int &rb = b;
const &rd = b;//权限放小
解释：变量变成了常量，限制了变量的范围，故为权限缩小。

求引用的字节个数

 sizeof中含义不同，引⽤计算结果为引⽤自身⼤⼩，但指针则是按照编译器的大小来判断(32位平台下占4个byte，64位下是8byte)

暂完.......