c++入门超级详解（含笔试面试注意点）_char c=97;cout<<c+1<<endl;输出结果为-CSDN博客

本文链接：https://blog.csdn.net/phenix_417/article/details/126971709

c++入门

1：作用域限定符

int main()
{
	int a = 1;
	printf("%d", ::a);
	return 0;
}

::表示作用限定符，当打印a的值时候，直接在全局中寻找a，不会再去局部变量寻找，因此报错。

2：命名空间

#include<iostream>
#include<stdlib.h>
int rand = 10；
int main()
{
	printf("%d", rand);
	return 0;
}

namespace的作用是定义一个新域。在C/C++中，后面学到的类是大量存在的，这些变量和函数都放在全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称本地化，避免命名冲突或污染。

例如上面的代码，rand是随机数函数的名称，在main中没有定义rand变量的大小，编译器首先在局部变量寻找，然后去全局中寻找，我们知道编译器预处理阶段会将头文件替换，也就是展开，这个时候相当于rand函数在全局作用域中，因此和全局变量rand冲突，所以c++提出了命名空间。

2.1：命名空间定义

#include<iostream>
namespace wjw
{
	int a = 0;
    int add(int a,int b)
    {
        return a+b;
    }
    struct wjw
    {
        int a = 0;
    };
}
int main()
{
	printf("%d", wjw::a);
	return 0;
}

命名空间中可以定义变量，函数以及类型。

命名空间可以嵌套定义。

#include<iostream>
namespace wjw
{
	int a = 0;
	namespace zqh
	{
		int c = 0;
	}
}
int main()
{
	int a = 1;
	printf("%d", wjw::a);
	return 0;
}

如果想要访问c变量则使用

printf("%d",wjw::zqh::c);

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

在.h文件和.cpp文件中比如有2个N1命名空间，最后合并成1个N1命名空间。

2.2:命名空间的使用

2.2.1：::限定符

#include<iostream>
namespace wjw
{
	int a = 0;
	int b = 0;
}
int main()
{
	int a = 1;
	printf("%d", wjw::a);
	return 0;
}

2.2.2：用using引用命名空间内部的某成员

#include<iostream>
namespace wjw
{
	int a = 0;
	int b = 0;
}
using wjw::a;
int main()
{
	int a = 1;
	printf("%d", a);
	return 0;
}

命名空间作为全局作用的范围，相当于和全局之间隔了一堵墙，如果使用using，相当于打破内部某个成员和全局的墙，直接放入全局中。

2.2.3：用using引用命名空间

#include<iostream>
namespace wjw
{
	int a = 0;
	
}
using namespace wjw;
int main()
{
	int a = 1;
	printf("%d", a);
	return 0;
}

这种方式就好像打破了wjw这个命名空间这堵墙，直接让其中的变量处于全局作域中。

3：C++输入&输出

#include<iostream>
using namespace std;
int main()
{
	int a = 0;
	cout << a << endl;
	return 0;
}

std是c++的标准库的命名空间名，标准库函数的实现都在这个命名空间中。c就是control，控制台的意思。

cout的方便之处在于自动识别类型，如下。

double a = 2.2;
int b = 4;
char c = 97;
cout<< a << ' ' << b << ' ' << c <<endl;

使用c语言的则需要格式控制%lf,%d,%c等。

但是由上述代码，我们可以看到空格还要手动再打一次格式比较麻烦，再比如如果需要输出每个变量的类型的时候，c++虽然可以使用type函数，但是相对于c语言复杂了一些。因此要酌情而定。

4：缺省参数

缺省参数是在声明和定义函数时为函数的某个参数决定一个缺省值，在调用该函数时候，如果没有指定实参则采用该形参对应的缺省值。

4.1：全缺省

void wjw(int a = 10, int b = 20)
{
    ...
}

4.2：半缺省

void wjw(int a,int b = 10,int c = 10)
{
    ....
}

注意：半缺省必须从右向左指定值，不可间隔。

并且函数声明和定义不要同时使用缺省，避免值不一样造成错误。

因此建议使用缺省值的时候，只在函数的声明中给出。

5：函数重载

在C语言中，比如我们想要设计一个int相加的add函数和一个double相加的add函数，那么我们设计的时候可能会如以下设计。

int intadd(int a ,int b)
{
    return a+b;
}
double doubleadd(double a, double b)
{
    return a+b;
}

因为2个函数的形参类型不一样，所以对函数名还要加以区分，而在c++中我们无需担心这样的问题。c++支持函数定义多个同名函数，但是有要求，需要函数的形参类型或者个数或者形参的顺序不一样。如下面的代码

//1：形参的类型不一样
int add(int a ,int b)
{
    return a+b;
}
double add(double a,double b)
{
    return a+b;
}
int main()
{
int ret1 = add(3,4);
int ret2 = add(3.3,4.4);
cout<< ret1 << ret2 << endl;
return 0;
}

//2：形参的个数不同
void wjw()
{
    ...
}
void zqh(int a)
{
    ...
}

//3：形参的顺序不一样
void wjw(int a,double b)
{
    ...
}
void zqh(double b,int a)
{
    ...
}

本质上第三个顺序不一样还是形参的类型不同。

注意：如果只是返回值不同的话是不能构成重载的，因为该同名函数具有二义性，编译器不知道调用哪个函数。

6：引用

6.1：引用的内存展示

int b = 10;
int& a = b;//引用
int* c = b;//指针

a是引用，引用相当于一个变量的别名，其实a和b使用的是一块空间。对a进行操作就是对b进行操作。

c是指针，指向b变量的地址。

6.2：引用特性

int main()
{
    int* a;
    char* b;
}

指针的定义可以不需要初始化。但是引用的定义必须初始化。

int main()
{
    int b = 0;
    int& a;//错误
    int& c = b;//正确 
    
}

int main()
{
    int& b = 10;
}

这是错误写法，常量的引用需要使用const引用。

int main()
{
    int a = 10;
    int b = 20;
    int& temp1 = a;
    temp1 = b;
}

错误写法，引用初始化后不能再引用其他的变量。

6.3：const引用

函数调用的时候会建立栈帧，形参在出了栈帧后会销毁这是常识，但是对于有返回值的，这种常量的返回值会被临时变量替换，临时变量具有常性，所以对函数的返回值进行的引用也必须使用const引用。

int add(int a,int b)
{
return a+b;
}
int main()
{
    const int& ret = add(3,4);
}

6.4：引用和指针的区别

1：引用必须初始化，指针不需要。

2：有空指针，但是没有空引用。

3：引用传值，指针传地址。

4：指针是对通过某个指针变量指向一个对象，对他指向的变量间接操作。引用是变量的别名，对引用的操作就是对变量自己的操作。

5：引用在初始化后，不能引用其他变量，指针可以更改指向的地址。

6：有多级指针，没有多级引用。

7：引用更安全。

7：内联函数

在C语言中，比如多次调用ADD这种小量代码的函数，比如是1w次，add函数代码量是3行。那就建立1w个栈帧，

为了减少开销，C语言中可以用宏，宏是替换的过程。在c++中，使用内联函数，可以做到用空间换时间。

比如3行代码调用1w次，用栈帧会消耗3w+3，内联函数消耗1w+3。

7.1：定义

以inline修饰函数，函数在编译的时候就直接展开而不是使用建立栈帧。提升运行效率

7.2：特性

内联函数不需要声明和定义分离。

7.3：宏的总结

优点：1.无需栈帧的开销，性能好。2.代码复用性好。

缺点：1.无类型安全检查。2.不方便调试。3.难写，难用，难维护。

8：auto关键字

8.1：起因

1：变量类型难写。

2：含义不明确导致容易出错。

因此使用auto可以自动匹配类型。

8.2：使用

int a = 10;
auto* b = a;
auto b = a;
auto& b = a;

在做指针的时候可以不需要加*，但是引用必须要加&。

但是使用的时候不可用多次匹配。下面就是错误用法。

int a = 10;
auto b = a,c = a;

8.3：函数参数不可用使用auto

因为根据形参类型无法推导参数具体什么类型。

8.4：不可用用auto定义数组。

9：基于auto的遍历数组for循环

int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    for(auto wjw : a)
    {
        cout<<a<<endl;
    }
}

10：nullptr指针

在c++中，定义NULL指针为字面常量0，而不是因此会导致很多错误，所以使用nullptr指针表示为空指针，并且无需头文件。

本篇c++入门到此结束，感谢观看，希望大家不要吝啬赞。