初识c++

最新推荐文章于 2024-07-19 23:11:36 发布

come on world

最新推荐文章于 2024-07-19 23:11:36 发布

阅读量936

点赞数 26

文章标签： c++ 学习开发语言 visual studio

本文链接：https://blog.csdn.net/comeonworld/article/details/140331223

版权

一、命名空间namespace

1.命名空间的价值

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

下面是c语言中出现的问题

#include<stdlib.h>
#include<time.h>
int main()
{
   int time = 20;
   printf("%d", time);
   return 0;
}

由于time与函数time()重名了，那么下面是报错

2.namespace的定义

1.namespace本质上是定义了一个域，这个域与全局域各自独立，以及与其他不同由namespace定义的域也各自独立，不同的域可以取相同的变量名，不用担心冲突

2.namespace定义：可以定义变量函数类

namespace name

{

//定义变量定义函数

int time; int Add(int x,int y );

//定义类或者结构体

struct fun{

int a; char b;};

//......

}//注意这里不打分号

下面使用namespace解决问题

#include<iostream>
#include<stdlib.h>
using namespace std;
namespace text{
int time = 20;
}
int main()
{
	cout << text::time;
	return 0;
}

3.C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量/函数/类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响。编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。

4.namespace只能定义在全局，当然他还可以嵌套定义。

5.项目工程中多文件中定义的同名namespace会认为是一个namespace，不会冲突。

6.C++标准库都放在一个叫std(standard)的命名空间中。

3.namespace的使用

1 指定命名空间访问，项目中推荐这种方式。
2 using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式 3 展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

1指定命名空间就是在使用该变量时在前面加入 ::

比如调用cout函数：std::cout<<"hello world";

2using将某个成员展开就是

namespace Text{

int a=10;

int n=20;

}

using Text::n;

这样在出现变量n时系统会默认认为是Text域中的n

下面来举一个例子来说明命名空间的可以跨文件以及嵌套

//这里是.cpp文件

using namespace std;
namespace text{
   namespace a{
       int time=10;
       int rand=20;
       int sleep=30;
   }
   namespace b {
       int time=5;
       int rand=10;
       int sleep=15;
   }
}
int main()
{
   cout << text::a::rand << " " << text::a::sleep <<" " << text::a::time << endl;
   cout << text::b::rand << " " << text::b::sleep <<" " << text::b::time << endl;
   cout << text::c::rand << " " <<text::c::sleep <<" " << text::c::time << endl;
   return 0;
}

//这里是.h文件

#pragma once
namespace text{
   namespace c{
       int time = 20;
       int rand = 40;
       int sleep = 60;
   }
}

结果是所有数据都可以打印出来

我们在使用命名空间时，一定要注意使用的是哪一个域的内容

二、C++输入&输出

1 <iostream> 是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输
出对象。
2 std::cin 是 istream 类的对象，它主要面向窄字符（narrow characters (of type char)）的标准输
入流。
3 std::cout 是 ostream 类的对象，它主要面向窄字符的标准输出流。
4 std::endl 是一个函数，流插入输出时，相当于插入一个换行字符加刷新缓冲区。
5 <<是流插入运算符，>>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）
使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动指定格式，C++的输入
输出可以自动识别变量类型，其实最重要的是C++的流能更好的支持自定义类型对象的输入输出。
6 cout/cin/endl等都属于C++标准库，C++标准库都放在一个叫std(standard)的命名空间中，所以要
通过命名空间的使用方式去用他们。
7 一般日常练习中我们可以using namespace std，实际项目开发中不建议using namespace std。
8 这里我们没有包含<stdio.h>，也可以使用printf和scanf，在包含<iostream>间接包含了。vs系列
编译器是这样的，其他编译器可能会报错。

我们可以举个例子

using namespace std;
int main()
{
	int zx;
	char zf;
	double sfd;
	cin >> zx >> zf >> sfd;
	cout << zx << " " << zf << " " << sfd<<endl;
	printf("%d %c %lf", zx, zf, sfd);
	return 0;
}

这个就证明了，c++比C语言多了一个自动识别类型，本质其实是函数重载

ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);

上面三段代码是在竞赛时，可以提高io速度的三段代码

三、缺省参数

1 缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地把
缺省参数也叫默认参数）
2 全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右左
依次连续缺省，不能间隔跳跃给缺省值。
3 带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
4 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省
值。

我们还是直接举例

//声明与定义分离这里是全缺省
int func(int c = 20); int func(int c){return c*40;}
//只能从右往左缺省参数这里是半缺省
int func2(int c, int a = 10, int b = 20);
int func2(int c, int a, int b)
{
   cout << c <<" " << a<<" " << b<<endl;
}
int main()
{
   //在调用时，如果缺省参数，函数会使用默认的参数
   //如果不缺，就是用用户输入的参数
   cout << func() << " " << func(30) << endl;
   func2(10, 5);
   func2(30);
   return 0;
}

四、函数重载

1.函数重载介绍

C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调用就表现出了多态行为，使用更灵活。C语言是不支持同一作用域中出现同名函数的。

直接举例看看函数重载

//1 函数参数类型不同
int Add(int a, int b){return a + b;}
double Add(double a, double b){return a + b;}
//2 函数参数个数不同
long long Add(int a, int b, int c,int d) { return a + b + c+d;}

//这里是定义

long long Add(int a, int b, int c, int d = 20);
long long Add(int a, int b, int c, int d) { return a + b + c + d; }
//注意缺省参数也可以构成函数重载
//3.函数参数顺序不同
int Add(char a, int b) { return a + b; };
int Add(int b, char a) { return a + b; };

//4返回值不同不可以作为函数重载的条件

在使用缺省参数构成重载时，可能会遇到问题

注意呀！如果缺省参数时，使用了4个参数，那么系统就不知道该调用那个函数

因为那个都可以被调用

那么可以使用命名空间解决问题

namespace{

long long Add(int a, int b, int c, int d = 20);
long long Add(int a, int b, int c, int d) { return a + b + c + d; }}

2.函数重载的原理

c++函数重载的原理：名字修饰

通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度
+函数名+类型首字母】

采用C语言编译器编译后结果

结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

采用C++编译器编译后结果

结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参
数类型信息添加到修改后的名字中

通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修
饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

五、引用

1.引用的概念和定义

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。比如：水壶传中李逵，宋江叫"铁牛"，江湖上人称"黑旋风"；林冲，外号豹子头；

类型& 引用别名 = 引用对象;

我们通过代码来看看什么是取别名

这里发现b c d的地址一样就证明了b c d 就是a的别名，不会独立开空间

2.引用的特性

1 引用在定义时必须初始化
2 一个变量可以有多个引用
3 引用一旦引用一个实体，再不能引用其他实体这三点很好理解，还是举例说明

int &a;//这是错误的看起来是声明，但是没有定义

int a=20;int &b=a;int &c=a;//没有问题，可以被多次引用

int a=20;int b=30;

int &c=a;int &c=b;//错误，一个引用只能引用一个实体

3.引用的使用

1.引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。 2.引用传参跟指针传参功能是类似的，引用传参相对更方便一些。举个例子就好

c语言

void Swap(int *a,int *b){ int temp=*a;*a=*b;*b=temp;}

c++

void Swap(int &a,int &b){int temp=a;a=b;b=temp;};

这样我们就不必去传指针，注意引用还是不能代替指针，引用只能有一层，指针可以由多级指针。

4.引用与指针的区别

1 语法概念上引用是一个变量的取别名不开空间，指针是存储一个变量地址，要开空间。
2 引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
3 引用在初始化时引用一个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。
4 引用可以直接访问指向对象，指针需要解引用才是访问指向对象。
5 sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位下
占4个字节，64位下是8byte) 6 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全一些

底层上来讲，引用是按照指针的方式实现的，实际是有空间的 我们来看看指针与引用的汇编

他们是一模一样的

5.const限定引用

1.可以引用一个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访
问权限在引用过程中可以缩小，但是不能放大。

举例

const int b=20 ;int &a=b;//const可读不可写

const int &c=30;//可行，但是值不可改变

2.需要注意的是类似int& rb = a*3; double d = 12.34; int& rd = d; 这样一些场
景下a*3的和结果保存在一个临时对象中， int& rd = d 也是类似，在类型转换中会产生临时对
象存储中间值，也就是说，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，所以这里
就触发了权限放大，必须要用常引用才可以。

//类型转换和运算的过程中，c++会产生临时变量，而这个临时变量是常量

所以要加上const

int b=10;const int &rb=b*3;

double a=3.14;const int &ra=a;

3.所谓临时对象就是编译器需要一个空间暂存表达式的求值结果时临时创建的一个未命名的对象，
C++中把这个未命名对象叫做临时对象。

六、inline 内联函数

1 用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，就可以提高效率。

2 inline对于编译器而言只是一个建议，也就是说，你加了inline编译器也可以选择在调用的地方不
开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。 inline适用于频繁调用的短小函数，对于递归函数，代码相对多一些的函数，加上inline也会被编译器忽略。

3 C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调
试，C++设计了inline目的就是替代C的宏函数。

// 实现一个ADD宏函数的常见问题
//#define ADD(int a, int b) return a + b;
//#define ADD(a, b) a + b;
//#define ADD(a, b) (a + b)

上面的宏定义全部是错误的

为什么不能加分号? 答：加上分号容易造成编译错误，分号加上后只要宏后有运算就会出错
为什么要加外面的括号? 答：比如在进行优先级更高的操作时，会先算优先级更高导致错误
为什么要加里面的括号? 答：同上

#define ADD(a, b) ((a) + (b))
int main()
{
int ret = ADD(1, 2);
cout << ADD(1, 2) << endl;
cout << ADD(1, 2)*5 << endl;
int x = 1, y = 2;
ADD(x & y, x | y); // -> (x&y+x|y)
return 0;
}

这个代码可以说明问题，如果里面不加括号，那么运算顺序为 x&(y+x)|y与原来不同

当然，如果是c++上的话直接在函数的返回类型前面加入inline即可

4 inline不建议声明和定义分离到两个文件，分离会导致链接错误。因为inline被展开，就没有函地
址，链接时会出现报错。

// F.h
#include <iostream>
using namespace std;
inline void f(int i);
// F.cpp
#include "F.h"
void f(int i)
{
cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
f(10);return 0;
}
//编译错误

上面使用内联时，一定要把声明定义放在一起

七、nullptr指针

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

也就是说在C语言中，NULL是(void *)0但是c++中NULL是常量0。这样就会出现问题

#include<iostream>
using namespace std;
void f(int x)
{
cout << "f(int x)" << endl;
}
void f(int* ptr)
{
cout << "f(int* ptr)" << endl;
}
int main()
{
f(0);
f(NULL);
f((void*)NULL);
// 编译报错：error C2665: “f”: 2 个重载中没有一个可以转换所有参数类型f((void*)NULL);
f(nullptr);
return 0;
}

解释，使用NULL指针是可能会出现歧义，因为从底层来讲NULL是指针，大家可能会以为他会调用f(int *ptr)这个函数，但是在c++中不存在c语言的隐式转换，也就是说void类型无法自动转化类型此时只能是调用f(int x)这个函数，所以出现了nullptr

C++11中引入nullptr，nullptr是一个特殊的关键字，nullptr是一种特殊类型的字面量，它可以转换
成任意其他类型的指针类型。使用nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被
隐式地转换为指针类型，而不能被转换为其他类型。