系列文章目录
本章节将带领大家共同学习c++的入门知识点,为后续的学习做好铺垫
提示:以下是本篇文章正文内容,下面案例可供参考
# 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)
暂完.......