ToB企服应用市场:ToB评测及商务社交产业平台
标题:
C++入门基础
[打印本页]
作者:
金歌
时间:
2024-8-19 22:59
标题:
C++入门基础
C++的第一个程序：
#include<iostream>
using namespace std;
int main()
{
cout << "hello zyb" << endl;
return 0;
}
复制代码
1.定名空间
1.1前情提要
在C语言中，我们知道在同一个域中，我们是不能定义两个同名的变量的，否则，会引起冲突的，但是，在我们的生活中，在公司上班时，会将几个人写的代码合并成一个代码时，难免会出现这种环境，如下所示：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int rand = 1;
int main()
{
printf("%d\n", rand);
return 0;
}
复制代码
通过上副图的报错信息可知，rand函数重定义了，由于头文件#include<stdlib.h>中也定义了一个叫rand的函数，与我们定义的整数rand名字重了，很麻烦，为了避免这种环境，在C++中引入了定名空间这个概念，就有了了一个关键字namespace。
1.2namespace的定义
（1）.定义定名空间，必要使用到namespace关键字，后面跟定名空间的名字，然后接一对{ }即可，{ }中即为定名空间的成员，定名空间中可以定义变量/函数/范例等，例。
namespace zyb//zyb是这个命名空间的名字
{
int rand = 10;//命名空间中的成员
}
复制代码
（2）.namespace本质上是定义一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，因此，如许就可以有用的避免上面遇到的冲突的这种环境，例。
namespace zyb
{
int rand = 10;
}
namespace zyx
{
int rand = 10;
}
复制代码
（3）.C++中域有函数局部域，全局域，定名空间域，类域；域影响的是编译时语法查找一个变量\函数\范例出处（声明或定义）的逻辑，所以有了隔离域，名字冲突这个问题就解决了，局部域和全局域，除了会影响编译查找逻辑，还会影响变量的生命周期，定名空间域和类域不会影响变量的生命周期。
补（1）：这里我们再增补一个知识点，当我们同时定义了两个变量a时，这两个变量一个是全局变量，一个是局部变量，最后在输出时是访问最近的谁人变量a，叫做就近原则，先在局部找，再在全局找，如下图所示。
当我们到一个全局域去找某一个变量的时间，我们用到一个域作用限定符"::"
如许，我们就可以去访问到定名空间中的信息了。
#include<stdio.h>
namespace zyb
{
int rand = 101;
struct node
{
int i = 10;
};
}
int main()
{
printf("%d", zyb::rand);
struct zyb::node p1;//zyb要写在node的前面，因为struct只是一个关键字，node才是结构体的名字。
return 0;
}
复制代码
（4）.namespace只能定义在全局，它还可以嵌套定义：
#include<stdio.h>
namespace zjhy
{
namespace zyb
{
int a = 19;
}
namespace zyx
{
int a = 29;
}
//...
}
int main()
{
printf("%d\n", zjhy::zyb::a);// 19
printf("%d\n", zjhy::zyx::a);// 29
return 0;
}
复制代码
（5）.项目工程中多文件定义的同名namespace会以为是一个namespace，不会起冲突。
由上图我们可知，stack.cpp文件和stack.h文件全部都使用同一个名字的定名空间分装起来，但我们在进行链接过程的时间，体系会以为这两个同名的定名空间是同一个定名空间，可以正常运行。
1.3定名空间的使用
（1）.指定定名空间访问，项目中推荐这种方式。
（2）.using将定名空间中的某个成员睁开，项目中经常访问的而且不存在冲突的推荐使用这种方式。
#include<stdio.h>
namespace zyb
{
int a = 10;
}
using namespace zyb;
int main()
{
printf("%d\n", a);//10
return 0;
}
复制代码
（3）.睁开定名空间中的全部成员，项目中不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。当然，我们也可以睁开常用的。
#include<stdio.h>
namespace zyb
{
int a = 10;
int b = 20;
}
using zyb::b;
int main()
{
printf("%d\n", zyb::a);//10
printf("%d\n", b);//20
return 0;
}
复制代码
2.C++的输入&输出
（1）.<iostream>是Input Output Stream的缩写，是标准的输入输出流库，定义了标准的输入输出对象。
（2）.std::cin是istream类的对象，他主要是面向窄字符的标准输入流。
（3）.std:
ut是ostream类的对象，他主要是面向窄字符的标准输出流（std::的意思是cin和cout都是在输入输出流库中的一个叫作std的定名空间中，若想使用cin和cout的话，就必须使用std::到std这个定名空间中去中找cin和cout）。
就像printf()输出函数，它在输出一个整数时，是将这个整数转化成字符输出来的，例如：
printf（"%d\n",1234);//1234
复制代码
就是将1234这个整数转化成4个字符输到屏幕中去，这里也是这个道理。
（4）.<<是流插入运算符，>>是流提取运算符，这些都是。（C语言还用这两个运算符做位移运算符左移/右移，C++中这两个运算符是作为输入和输出）
（5）.std::endl是一个函数，流插入输出时，相当于插入一个换行字符加刷新缓冲区。
#include<iostream>
using namespace std;
int main()
{
int a = 0;
int b = 0;
cin >> a >> b;//输入随机地两个int类型的值。
cout << b << " " << a << endl;//输出两个值。
return 0;
}
复制代码
（6）.使用C++输入输出会变得很方便，不必要像printf/scanf输入输出时的那样，必要手动指定格式，C++的输入输出可以主动辨认变量范例，其实最重要的是C++的流能更好地支持自定义范例对象地输入和输出。
#include<iostream>
using namespace std;
int main()
{
int a = 10;
double b = 2.1;
cout << a << " " << b << endl;
int c = 0;
double d = 0;
cin >> c >> d;
cout << c << " " << d << endl;
return 0;
}
复制代码
我们在输出d的时间，只输出了小数点最后5位，是由于C++默认输出小数点为5位（这里再来提醒一下大家，就是如果想要控制小数点的精度，发起使用C语言的那一套来控制，C++过于麻烦）。
3.缺省参数
（1）.缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用函数时，如果没有传参，则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数（有些地方把缺省参数也叫做默认参数）。
#include<iostream>
using namespace std;
void func(int a = 2)//2就是一个缺省值
{
cout << a << endl;
}
int main()
{
func();//2,没有传参时，使用函数的默认值，也就是缺省值（此处指的是缺省值2）
func(5);//5,有参数时，使用参数（这里的参数是5）
return 0;
}
复制代码
（2）.全缺省参数就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右到左必须依次一连缺省，不能隔断跳跃给缺省值。
// 全缺省
void Func1(int a = 10, int b = 20, int c = 30);
// 半缺省
void Func2(int a, int b = 20, int c = 30);
void Func3(int a = 10, int b, int c = 30);//编译器会报错，因为这里间隔跳跃给参省值
void Func4(int a = 10, int b = 20, int c);//编译器会报错，因为这里没有从右往左依次参省
复制代码
（3）.带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
#include<iostream>
using namespace std;
void Func(int a = 10, int b = 20, int c = 30)
{
cout << a << " " << b << " " << c << endl;
}
int main()
{
Func(5);//5 20 30
Func(5, 10);//5 10 30
Func(5, 10, 15);//5 10 15
return 0;
}
复制代码
（4）.函数的声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值（函数的定义中不能给缺省值）。
#include<iostream>
using namespace std;
void func(int a = 10, int b = 20, int c = 30);
int main()
{
func();
return 0;
}
void func(int a, int b, int c)
{
cout << a << " " << b << " " << c << endl;
}
复制代码
4.函数重载
C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数不同或者范例不同。如许C++函数调用就表现出了多态举动，使用的更加机动。C语言是不支持同一作用域中出现同名函数的。
// 1.参数类型不同
void Add(int left, int right)
{
cout << "Add(int left, int right)" << endl;
}
void Add(double left, double right)
{
cout << "Add(double left, double right)" << endl;
}
// 2.参数个数不同
void f()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << endl;
}
// 3.参数类型顺序不同
void func(int a, double b)
{
cout << "func(int a, double b)" << endl;
}
void func(double b, int a)
{
cout << "func(double b, int a)" << endl;
}
复制代码
5.引用
4.1引用的概念
引用不是新定义⼀个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同⼀块内存空间。
范例& 引用名=引用对象
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& b = a;//引用，b是a的别名（就是另一个名字）
//类型& 引用名=引用对象
b = 20;
cout << b << " " << a << endl;//20 20
cout << &b << " " << &a << endl;//输出来的两个地址都一样
return 0;
}
复制代码
4.2引用的特性
（1）.引用必须初始化。
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& b = a;
b = 20;
cout << b << " " << a << endl;
cout << &b << " " << &a << endl;
return 0;
}
复制代码
（2）.一个变量可以有多个引用。
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& b = a;
int& c = a;
int& d = a;
b = 20;
cout << b << " " << a << endl;
cout << &b << " " << &a << endl;
return 0;
}
复制代码
（3）.引用一旦引用一个实体，就不可以再引用其他实体。
4.3引用的使用
（1）.引用在实践中主要是于引用传参和引用做返回值中减少拷贝进步效率和改变引用对象时同时改变被引用对象。
（2）.引用传参跟指针传参功能是雷同的，引用传参相对更⽅便⼀些。
（3）.引用返回值的场景相对比较复杂，我们在这⾥简单讲了⼀了局景，还有⼀些内容后续类和对象章节中会继续深入解说。
（4）.引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引⽤跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。
（5）.⼀些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目标是简化程序，避开复杂的指针，但是许多同砚没学过引用，导致⼀头雾水。
4.4const引用
（1）.可以引用一个const对象，但是必须是const引用。const引用也可以引用平凡对象，由于对象的访问权限在引用过程中可以缩小，但是不能放大。
#include<iostream>
using namespace std;
int main()
{
int a = 10;//a的访问权限是既可以读取，也可以修改
int& b = a;//b的访问权限是既可以读取，也可以修改
//引用权限不能放大，只能是权限相同或权限缩小
const int a1 = a;//a1被const修饰，访问权限只是读取a，没有修改它，属于权限缩小
const int& a2 = a;//a2被const修饰，访问权限只是读取，没有修改它，属于权限缩小
const int c = 20;//c被const修饰，访问权限只能读取，不能修改
const int& d = c;//d被const修饰，访问权限只能读取，不能修改，属于权限相同
return 0;
}
复制代码
c1是既可以读取，也可以修改，而c只能读取，不能修改，上面的那张图片中的第12行的那句代码的问题是属于权限放大的问题。（也就是说，赋给c1的谁人值也必须是既可以读取，也可以修改）
（2）.这里我们再来说一个有关临时对象的概念，所谓的临时对象就是编译器必要一个空间暂时存放表达式求值结果时临时创建的一个未定名的对象，C++中把这个未定名对象叫做临时对象。
（3）.不必要注意的是雷同 int& rb = a*3; double d = 12.34; int& rd = d; 如许⼀些场景下a*3的和结果保存在⼀个临时对象中， int& rd = d 也是雷同，在范例转换中会产⽣临时对象存储中间值，也就是时，rb和rd引⽤的都是临时对象，⽽C++规定临时对象具有常性（换句话说，就是被const修饰的），所以这⾥就触发了权限放⼤，必须要⽤常引⽤（const修饰）才可以。
(a+b)是一个表达式，它的结果会被存放在临时对象中，这个临时对象没著名字而且具有常性，只能读取，不能修改，此时若用int范例去引用的话，会将权限放大，从而出错，因此，必须用const修饰。（范例转换也是如此）
using namespace std;
int main()
{
int a = 10;
int b = 20;
const int& c = (a + b);
double d = 2.34;
const int& e = d;
cout << c << " " << e << endl;//30 2
return 0;
}
复制代码
4.5指针与引用的关系
C++中指针和引⽤就像两个性格迥异的亲兄弟，指针是哥哥，引⽤是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有⾃⼰的特点，互相不可替代。
（1）.语法概念上引⽤是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间。
（2）.引⽤在定义时必须初始化，指针发起初始化，但是语法上不是必须的。
（3）.引⽤在初始化时引⽤⼀个对象后，就不能再引⽤其他对象；⽽指针可以在不断地改变指向对象。
（4）.引⽤可以直接访问指向对象，指针必要解引⽤才是访问指向对象。
（5）.sizeof中含义不同，引⽤结果为引⽤范例的⼤⼩，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)
（6）.指针很容易出现空指针和野指针的问题，引⽤很少出现，引⽤使⽤起来相对更安全⼀些。
6.inline
#include<iostream>
using namespace std;
inline int Add(int x, int y)
{
int a = x + y;
return a;
}
int main()
{
int c = Add(3, 5);//8
return 0;
}
复制代码
（1）.⽤inline修饰的函数叫做内联函数，编译时C++编译器会在调⽤的地⽅睁开内联函数，如许调⽤内联函数就必要建⽴栈帧了，就可以提⾼效率。
（2）.inline对于编译器⽽⾔只是⼀个发起，也就是说，你加了inline编译器也可以选择在调⽤的地⽅不睁开，不同编译器关于inline什么环境睁开各不雷同，由于C++标准没有规定这个。inline适⽤于频仍调⽤的短⼩函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。
（3）.C语⾔实现宏函数也会在预处置惩罚时替换睁开，但是宏函数实现很复杂很容易出错的，且不⽅便调试，C++设计了inline⽬的就是替代C的宏函数。
（4）.inline不发起声明和定义分离到两个⽂件，分离会导致链接错误。由于inline被睁开，就没有函数地址，链接时会出现报错。
7.nullptr
NULL实际上就是一个宏，代码如下所示：
#ifndef NULL
#ifdef __cplusplus//如果是在C++中，NULL代表的是0
#define NULL 0
#else//如果不是在C++中，NULL代表的是无类型的指针
#define NULL ((void *)0)
#endif
#endif
复制代码
（1）.C++中NULL大概被定义为字⾯常量0，或者C中被定义为⽆范例指针(void*)的常量。岂论采取何种定义，在使⽤空值的指针时，都不可避免的会遇到⼀些⿇烦，本想通过f(NULL)调⽤指针版本的f(int*)函数，但是由于NULL被定义成0，调⽤了f(int x)，因此与程序的初志相悖。f((void*)NULL);调⽤会报错。
（2）.C++11中引⼊nullptr，nullptr是⼀个特别的关键字，nullptr是⼀种特别范例的字⾯量，它可以转换成任意其他范例的指针范例。使⽤nullptr定义空指针可以避免范例转换的问题，由于nullptr只能被隐式地转换为指针范例，⽽不能被转换为整数范例。
OK，谢谢大家的观看，感谢大家的支持！
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)
Powered by Discuz! X3.4
ut是ostream类的对象，他主要是面向窄字符的标准输出流（std::的意思是cin和cout都是在输入输出流库中的一个叫作std的定名空间中，若想使用cin和cout的话，就必须使用std::到std这个定名空间中去中找cin和cout）。
