【一】【C++】C++入门

已于 2024-01-27 22:14:05 修改
阅读量1k 收藏 18
点赞数 20
分类专栏： C++ 文章标签： c++
于 2024-01-22 16:46:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74163972/article/details/135751851
版权

命名空间

命名空间namespace

使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染。

 

/*1 rand与rand()冲突*/
#include <stdio.h>
#include <stdlib.h>
int rand = 10;

int main() {
    printf("%d\n", rand);
    return 0;
 }
 

stdlib.h库中有一个函数rand()，此时如果我们想要定义一个int类型，名字为rand的变量，此时就会报错。
 

 

 

/*2 在main中定义rand不会报错*/
#include <stdio.h>
#include <stdlib.h>
int main() {
    int rand = 10;
    printf("%d\n", rand);
    return 0;
 }
 

在main函数中定义rand变量，并且打印，此时不会报错。
 

 

 

/*3 在main中定义rand不会报错，但是此时rand()无法使用*/
#include <stdio.h>
#include <stdlib.h>
int main() {
    int rand = 10;
    rand = rand();
    printf("%d\n", rand);
    return 0;
 }
 

但是此时rand()无法使用。
 

 

这就是命名冲突。为了避免这种情况我们引入了命名空间，namespace关键字。
 

命名空间namaspace的定义
 

 

/*4 引入命名空间*/
#include <stdio.h>
#include <stdlib.h>
namespace _240121 {
    int rand = 10;
    int add(int left, int right) {
        return left + right;
    }
    struct node {
        int data;
        struct node* next;
    };
 }

int main() {
    _240121::rand = rand();
    printf("%d\n", _240121::rand);
    return 0;
 }
 

命名空间的定义规则：namespace+空间名称+{}
 

命名空间namaspace的使用
 

此时命名空间_240121是一个独立的空间，我们不能直接对该空间内的成员进行访问。
 

命名空间的使用有三种方式：
 

1.加命名空名称及作用域限定符
 

 

/*5 命名空间的使用方法 1.加命名空间名称及作用域限定符*/
#include <stdio.h>
#include <stdlib.h>
namespace _240121 {
    int rand = 10;
 }

int main() {
    printf("%d\n", _240121::rand);
    return 0;
 }
 

想要使用_240121中的成员时，在成员的前面添加成员所属命名空间的名称以及“::”作用域限定符。此时可以完全避免命名冲突。
 

此时编辑器直接到_240121命名空间中访问rand成员。
 

使用规则：命名空间名称+作用域限定符+具体某个成员
 

2.使用using将命名空间中某个成员引入
 

 

/*6 命名空间的使用方法 2.使用using将命名空间中某个成员引入
 冲突解决不能用using引入成员，引入之后在外面还是有冲突，
 而是应该直接加命名空间名称以及作用域限定符，直接找到命名空间中的rand*/
#include <stdio.h>
#include <stdlib.h>
namespace _240121 {
    int rand = 10;
 }
using _240121::rand;
int main() {
    printf("%d\n", rand());
    printf("%d\n", rand);
    return 0;
 }
 

 

使用using 将_240121命名空间中rand成员引入到全局中，此时rand与stdlib.h中的rand会产生冲突。
 

 

#include <stdio.h>
#include <stdlib.h>
namespace _240121 {
    int a = 10;
 }
using _240121::a;
int main() {
    printf("%d\n", a);
    return 0;
 }
 

此时把_240121命名空间中a这个成员引入了，可以直接对a这个成员进行访问。
 

使用规则：using+命名空间名称+作用域限定符+具体某个成员
 

3.使用using将namespace命名空间名称引入
 

 

/*9 命名空间的使用方法 3.使用using namespace 命名空间名称引入*/
#include <stdio.h>
#include <stdlib.h>
namespace _240121 {
    int a = 10;
    int b = 20;
 }
using namespace _240121;
int main() {
    printf("%d\n%d", a, b);
    return 0;
 }
 

 

此时把_240121命名空间中所有成员都引入，对所有成员都可以直接访问。
 

 

/*8 命名空间的使用方法 3.使用using namespace 命名空间名称引入
 冲突解决不能用using引入命名空间，引入之后在外面还是有冲突，
 而是应该直接加命名空间名称以及作用域限定符，直接找到命名空间中的rand
 综上所述，冲突解决，可以用命名空间解决，但是此时命名空间的引入只能通过，
 加命名空间名称及作用域限定符，来解决
 而不能用using 引入成员或者整个命名空间*/
#include <stdio.h>
#include <stdlib.h>
namespace _240121 {
    int rand = 10;
 }
using namespace _240121;
int main() {
    printf("%d\n", rand());
    printf("%d\n", rand);
    return 0;
 }
 

冲突解决只能用第一种方式解决，但是平常我们一般不会遇到命名冲突的问题。
 

使用规则：using namespace+命名空间名称
 

命名空间的使用习惯
 

std命名空间的使用惯例：
 

std是C++标准库的命名空间，如何展开std使用更合理呢？
 

  1.  
    在日常练习中，建议直接using namespace std即可，这样就很方便。
     
  2.  
    using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对
     
 

象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模
 

大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 +
 

using std::cout展开常用的库对象/类型等方式（第一种方式避免命名冲突）
 

C++输入输出
 

输出cout
 

 

/*10 C++的输出*/
#include <iostream>
using namespace std;//std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
int main() {
    int a = 10;
    cout << a << endl;//输出，a数据流向cout，即屏幕
    return 0;
 }
 

可以理解为cout为屏幕，a变量流向屏幕，即打印a，endl再流向屏幕，即换行。
 

cout的使用需要使用#include <iostream>头文件。
 

cout是输出，相当于C语言中的printf。
 

我们会发现，cout打印数据不需要规定他的数据类型，而C语言使用printf打印数据时需要告诉编辑器该打印数据的数据类型是什么，这也是C++的一种优化。
 

输入cin
 

 

/*11 C++的输入*/
#include <iostream>
using namespace std;//std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
int main() {
    int a;
    cin >> a;//屏幕数据流向a
    cout << a << endl;
    return 0;
 }
 

可以理解为cin表示屏幕，屏幕输入的数据流向a变量。
 

cin的使用同样需要使用#include <iostream>头文件。
 

cin是输入，相当于C语言中的scanf。
 

cin同样不需要规定数据类型。
 

 

自动识别数据类型
 

 

/*12 C++的输入输出可以自动识别数据类型*/
#include <iostream>
using namespace std;//std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
int main() {
    int a;
    double b;
    char c;
    cin >> a;//屏幕数据流向a
    cin >> b >> c;
    cout << a << endl;
    cout << b << "  " << c << endl;
    return 0;
 }
 

cout和cin都可以自动识别数据类型。
 

缺省参数
 

缺省参数的定义
 

 

/*13 缺省参数,缺省参数是声明或定义函数时为函数的参数指定一个缺省值。*/
#include <iostream>
using namespace std;//std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中

void Func(int a=10){//定义函数时候
    cout<<a<<endl;
 }
int main() {
    Func();
    Func(20);

    return 0;
 }
 

在函数定义的时候，对参数进行“赋值”，这不是真正的赋值，而是缺省参数的定义。
 

当这个形参缺少的时候，就是用我们定义的10，如果形参没有缺少，就使用我们传过去的形参值。
 

 

缺省参数的分类
 

  1.  
    全缺省
     
  2.  
    半缺省
     
 

 

1.全缺省
 

 

/*14 缺省参数,全缺省。*/
#include <iostream>
using namespace std;//std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中

void Func(int a = 10,int b = 20, int c = 30) { //定义函数时候
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
 }
int main() {
    Func();

    return 0;
 }
 

此时Func函数中有三个参数，a，b，c，且这三个参数都是缺省参数。
 

2.半缺省
 

 

/*15 缺省参数,半缺省。*/
#include <iostream>
using namespace std;//std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中

void Func(int a ,int b = 20, int c = 30) { //定义函数时候
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
 }
int main() {
    Func(10);

    return 0;
 }
 

不严谨的说法就是，不是全缺省的就是半缺省。
 

注意事项
 

半缺省从右往左依次给出缺省值
 

需要注意的是半缺省，必须从右往左依次给出缺省值。
 

 

/*16 缺省参数,半缺省。
 1.半缺省必须从右往左依次给出*/
#include <iostream>
using namespace std;

void Func(int a =10,int b , int c = 30) {
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
 }
int main() {
    Func(10);

    return 0;
 }
 

 

半缺省应该分为两个部分，左边部分无缺省值，右边部分有缺省值。
 

 

缺省参数不能在函数声明和定义中同时出现
 

 

/*17 缺省参数。
 1.半缺省必须从右往左依次给出
 2.缺省参数不能在函数声明和定义中同时出现*/
#include <iostream>
using namespace std;

void Func(int a = 10);
void Func(int a = 20) {
    cout << a << endl;
 }
int main() {

    return 0;
 }
 

此时编辑器不知道使用那一个缺省值。
 

函数重载
 

函数重载定义
 

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这  些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型  不同的问题。
 

 

/*18 函数重载。
 函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这
 些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型
 不同的问题。*/
#include <iostream>
using namespace std;
//参数类型不同
int add(int left, int right) {
    cout << "int add(int left,int right)" << endl;
    return left + right;
 }
double add(double left, double right) {
    cout << "double add(int left,int right)" << endl;
    return left + right;
 }
//参数个数不同
void f() {
    cout << "void f()" << endl;
 }
void f(int a) {
    cout << "void f(int a)" << endl;
 }
//参数类型顺序不同
void f(int a, char b) {
    cout << "void f(int a, char b)" << endl;
 }
void f(char b, int a) {
    cout << "void f(char b, int a)" << endl;
 }
int main() {

    add(10, 20);
    add(10.1, 20.2);
    f();
    f(10);
    f(10, 'a');
    f('a', 10);
    return 0;
 }
 

实现函数重载，首先函数名需要相同，其次是，形参列表(参数个数 或 类型 或 类型顺序)不同。
 

需要注意的是，
 

 

/*18 函数重载。
 函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这
 些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型
 不同的问题。*/
#include <iostream>
using namespace std;

//参数类型顺序不同,不是参数顺序不同
void f(int a, int b) {
    cout << "void f(int a, int b)" << endl;
 }
void f(int b, int a) {
    cout << "void f(int b, int a)" << endl;
 }
int main() {
    f(10, 1);
    f(1, 10);
    return 0;
 }
 

这样是不构成函数重载的，因为参数个数是一样的，参数的类型和类型顺序也是一样的。
 

函数重载原理
 

c：函数名 c++：_Z+函数长度+函数名+类型首字母。
 

这是C语言和C++对于函数的修饰规则。
 

C++中：
 

 

而C语言中修饰规则是函数名。
 

引用
 

引用的定义
 

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空  间，它和它引用的变量共用同一块内存空间。
 

 

/*20 引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
 间，它和它引用的变量共用同一块内存空间。
 类型& 引用变量名(对象名) = 引用实体；*/
#include <iostream>
using namespace std;

void testRef(){
    int a=10;
    int& ra=a;
    cout<<a<<endl;
    cout<<ra<<endl;

    cout<<&a<<endl;
    cout<<&ra<<endl;
 }
int main() {
    testRef();
    return 0;
 }
 

 

他们的地址是一样的，引用只是给变量取了一个别名，他们共用同一内存空间。
 

引用的特性
 

/*21.引用的特性
 1.引用在定义时必须初始化
 2.一个变量可以有多个引用
 3.引用一旦引用一个实体，再不能引用其他实体*/

#include <iostream>
using namespace std;

void test1(){
    int a=10;
    int& ra;
    ra=a;
    cout<<ra<<endl;
    cout<<endl;
 }
void test2(){
    int a=10;
    int& ra=a;
    int& rra=a;
    cout<<ra<<endl;
    cout<<rra<<endl;
    cout<<endl;
 }
void test3(){
    int a=10;
    int& ra=a;
    int b=20;
    ra=b;
    ra=30;
    cout<<ra<<endl;
    cout<<a<<endl;
    cout<<b<<endl;
 }
int main() {
    test1();
    test2();
    test3();
    return 0;
 }
 

1.引用必须初始化
 

在test1中，定义int类型的引用但是没有初始化化，系统报错。
 

 

2.一个变量可以用多个引用
 

运行test2得到，
 

 

变量a可以有多个引用，也就是可以有多个别名，就像一个人在不同阶段会有其对应的外号，不同的人取的不同的外号，他们都是一个人的别名。
 

3.引用一旦引用一个实体，就不能引用其他实体
 

运行test3得到，
 

 

我们发现b变量是20，我们没有改变b变量的值。也就是ra=b并不能使得ra变成b的别名。
 

ra=b的真正含义是b的值赋值匪ra，而ra是a的别名。
 

引用一旦引用一个实体，就不能引用其他实体。
 

常引用
 

用const修饰，表示只读。
 

 

/*22.常引用 */
#include <iostream>
using namespace std;

void testconstref1() {
    const int a = 10;
    int& ra = a;//该语句编译时会出错，a为常量
}
void testconstref2(){
    const int a = 10;
    const int& ra = a;
    cout << ra << endl << endl;
 }
void testconstref3(){
    int& b = 10;// 该语句编译时会出错，b为常量

    const int& b = 10;

    double d = 3.14;
    int& rd = d;// 该语句编译时会出错，类型不同
}
void testconstref4(){
    double d = 3.14;
    const int& rd = d;//常引用自动类型转换
    const double& rrd=d;
    cout<<rd<<endl<<endl;
    cout<<rrd<<endl<<endl;
 }
int main() {
    testconstref1();
    testconstref2();
    testconstref3();
    testconstref4();
    return 0;
 }
 

testconstref1中定义了a变量是const只读，此时不能用ra引用a变量，因为如果用ra表示a的别名，此时ra是可读可写，我们用ra改变了a的值，这样就不合理了。
 

testconstref2中用const修饰的ra引用a，此时ra表示a的别名，且ra是只读的，这样就不会发生通过ra改变只读a的值的情况，所以这个用法是正确的。
 

testconstref3中b引用常量10，b是可读可写的，但是常量10是只读的，不可以这样使用。
 

而const int& b = 10; 用只读的b引用常量10这个用法是正确的。
 

double d = 3.14; int& rd = d;// 该语句编译时会出错，类型不同
 

此时rd引用的类型是int而d为double，类型不同会报错。
 

testconstref4中用常量引用rd表示d的别名，这个用法是可以的，可以理解为只读的引用，可以转换数据类型。
 

引用的使用场景
 

1.做参数
 

2.做返回值
 

 

/*23.引用的使用场景 */
#include <iostream>
using namespace std;

void swap(int& a,int&b){
    int temp=a;
    a=b;
    b=temp;
 }
int& count(){
    static int n=20;//出了作用域还存在
    n++;
    return n;
 }
int main() {
    int a=1,b=10;
    swap(a,b);
    cout<<a<<endl<<b<<endl;

    int& ret=count();
    cout<<ret<<endl;
    return 0;
 }
 

1.做参数
 

2.做返回值
 

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
 

 

/*24.引用
 如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用
 引用返回，如果已经还给系统了，则必须使用传值返回。 */
#include <iostream>
using namespace std;

int& add(int a, int b) {
    int c = a + b;
    return c;
 }
int main() {
    int& ret = add(1, 2);
    cout << "add(1,2)=" << ret << endl;
    return 0;
 }
 

程序会崩掉，因为c变量出来作用域就还给系统了，而ret是c的别名，而c已经不存在了。
 

传值传引用效率比较
 

1.做函数参数
 

 

/*25.传值和传引用的效率比较
 作为函数参数*/
#include <iostream>
using namespace std;
#include <time.h>

struct A {
    int a[10000];
 };
void testfunc1(A a) {}

void testfunc2(A& a) {}

void testrefandvalue() {
    A a;

    size_t begin1 = clock();
    for (size_t i = 0; i < 1000000; i++) {
        testfunc1(a);
    }
    size_t end1 = clock();

    size_t begin2 = clock();
    for (size_t i = 0; i < 1000000; i++) {
        testfunc2(a);
    }
    size_t end2 = clock();

    cout << "testfunc1(A a)-->time:" << end1 - begin1 << endl;
    cout << "testfunc2(A a)-->time:" << end2 - begin2 << endl;
 }

int main() {
    testrefandvalue();
    return 0;
 }
 

 

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
 

2.做函数返回值
 

 

/*26.传值和传引用的效率比较
 作为函数返回值返回*/
#include <iostream>
using namespace std;
#include <time.h>

struct A {
    int a[10000];
 };

A a;

A testfunc1() {
    return a;
 }

A& testfunc2() {
    return a;
 }

void testrefandvalue() {
    size_t begin1 = clock();
    for (size_t i = 0; i < 1000000; i++) {
        testfunc1();
    }
    size_t end1 = clock();

    size_t begin2 = clock();
    for (size_t i = 0; i < 1000000; i++) {
        testfunc2();
    }
    size_t end2 = clock();

    cout << "testfunc1(A a)-->time:" << end1 - begin1 << endl;
    cout << "testfunc2(A a)-->time:" << end2 - begin2 << endl;
 }

int main() {
    testrefandvalue();
    return 0;
 }
 

 

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
 

引用和指针的区别
 

引用和指针的不同点:
 

1.引用概念上定义一个变量的别名，指针存储一个变量地址。
 

2.引用在定义时必须初始化，指针没有要求
 

3.引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
 

4.引用没有NULL引用，但指针有NULL指针
 

5.在sizeof中含义不同:引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
 

6.引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
 

7.有多级指针，但是没有多级引用
 

8.访问实体方式不同，指针需要显式解引用，引用编译器自己处理
 

9.引用比指针使用起来相对更安全
 

内联函数
 

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
 

 

/*27.内联函数
 无法声明和定义分离
 空间换时间
 将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不
 是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。*/
#include <iostream>
using namespace std;

inline int add(int left, int right) {
    return left + right;
 }
int main() {
    int ret;
    ret = add(1, 2);
    cout << ret << endl;
    return 0;
 }
 

  1.  
    inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
     
  2.  
    inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
     
  3.  
    inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
     
 

auto关键字
 

auto定义
 

auto作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
 

 

/*28.auto关键字*/
#include <iostream>
using namespace std;

int testauto(){
    return 10;
 }
int main(){
    int a=10;
    auto b=a;
    auto c='a';
    auto d=testauto();

    cout<<typeid(b).name()<<endl;
    cout<<typeid(c).name()<<endl;
    cout<<typeid(d).name()<<endl;
//    auto e;

    return 0;
 }
 
 

注意：使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。
 

auto使用规则
 

1.auto与指针和引用结合使用
 

 

/*29.auto关键字的使用规则*/
#include <iostream>
using namespace std;

int main() {
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;

    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;

    *a = 20;
    cout<<x<<endl;
    *b = 30;
    cout<<x<<endl;
    c = 40;
    cout<<x<<endl;

    return 0;
 }
 

 

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
 

2.在同一行定义多个变量
 

 

/*30.auto关键字的使用规则
 一行的变量数据类型必须是相同的*/
#include <iostream>
using namespace std;

void testauto() {
    auto a = 1, b = 2;
    cout << a << endl << b << endl;

    auto c=3,d=4.0;//报错
    cout<<c<<endl<<d<<endl;
 }
int main() {
    testauto();

    return 0;
 }
 

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
 

不能使用auto的场景
 

 

/*31.auto关键字无法使用的场景*/
#include <iostream>
using namespace std;

void testauto(auto a) {

 }

void testauto() {
    int a[] = {1, 2, 3};
    auto a[] = {1, 2, 3};
 }
int main() {

    return 0;
 }
 
 

1.auto不能作为函数的参数
 

2.auto不能直接用来声明数组
 

范围for
 

 

/*32.范围for遍历*/
#include <iostream>
using namespace std;


void testfor() {
    int array[] = {1, 2, 3, 4, 5};
    for (auto& e : array) {
        e *= 2;
    }
    for (auto e : array) {
        cout << e << endl;
    }
 }
int main() {
    testfor();
    return 0;
 }
 
 

for（auto& e：array）表示用e作为第一个元素的别名，接着用e作为第二个元素的别名，一直到e作为最后一个元素的别名为止。
 

for (auto e : array) 表示用e作为临时变量，其值等于第一个元素的值，接着e作为临时变量，其值等于第二个元素的值。一直到e作为临时变量，其值等于第最后一个元素的值为止。
 

nullptr空指针
 

 

/*33.nullptr*/
#include <iostream>
using namespace std;

void f(int) {
    cout << "f(int)" << endl;
 }
void f(int*) {
    cout << "f(int*)" << endl;
 }
int main() {
    f(0);
//    f(NULL);
    f((int*)NULL);
    f(nullptr);
    return 0;
 }
 

传入Null实际上是想调用f(int*) ，但是Null可能被定义为0或者无类型指针（void*）的常量。
 

而传nullptr就可以直接调用f(int*) 。
 

结尾
 

 

最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。
 

 

同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。
 

 

谢谢您的支持，期待与您在下一篇文章中再次相遇！

                

        

        

    

  


    


                



	

		

			

				
					
C++入门基础(万字总结）（建议收藏！！！）

				
			

			

				

					IamGreeHand的博客
				

				

					09-22
					
					26万+
					
				

			

		

		

			
				
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体

			
		

	



                

            
              



	

		

			

				
					
C++入门教程（一）

				
			

			

				

					qq_29887971的博客
				

				

					08-26
					
					7517
					
				

			

		

		

			
				
C++初学知识

			
		

	



              


  
              

                


	

		

			

				
					
C++基础入门（超详细）

				
			

			

				

					qq_44859533的博客
				

				

					07-02
					
					6万+
					
				

			

		

		

			
				
全网很全的C++基础入门，针对每一个概念以及概念之后的代码实现运行结果。可以帮助新手很快上手，也可以帮助老手回顾C++。

			
		

	





	

		

			

				
					
C++入门基础

				
			

			

				

					2301_76564849的博客
				

				

					09-12
					
					3743
					
				

			

		

		

			
				
•定义命名空间，需要使⽤到namespace关键字，后⾯跟命名空间的名字，然后接⼀对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。//命名空间里可以定义变量/函数/类型int Add(int x, int y)//整数相加的函数struct Node//定义一个结构体int val;//其中::叫做域作用限定符•namespace本质是定义出⼀个域，这个域跟全局域各⾃独⽴，不同的域可以定义同名变量，所以上。

			
		

	



		

			
		



	

		

			

				
					
C++：C++入门基础

				
			

			

				

					weixin_51142926的博客
				

				

					02-20
					
					6772
					
				

			

		

		

			
				
C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

			
		

	





	

		

			

				
					
C++教程从入门到实战

					
热门推荐

				
			

			

				

					believer
				

				

					08-09
					
					15万+
					
				

			

		

		

			
				
C++基础教程
一、数据类型
1.1、第一个C++程序

1.2、数据类型

1.3、常量及符号


1、整型常量：整型常量可以分为有符号整型常量和无符号整型常量


八进制：以0开头，即以0作为八进制数的前缀，每位取值范围是0~7，八进制数通常是无符号数。

例如：016、0101、0128都是合法的八进制数



十六进制：以0x或者0X开头，其数码取值范围0 ~ 9，以及A ~ F或者a ~ f

例如：0X2A1、0XC5、0XFFFF都是合法的16进制数





2、实型常量

小数表示法：由整

			
		

	





	

		

			

				
					
C++入门基础（万字详解！！！）

				
			

			

				

					忘忧.
				

				

					08-15
					
					4万+
					
				

			

		

		

			
				
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

			
		

	





	

		

			

				
					
【C++】C++ 入门

				
			

			

				

					在平淡的日子里寻找存在的价值
				

				

					09-21
					
					6151
					
				

			

		

		

			
				
C++ 入门基础知识 -- 命名空间、函数重载、缺省参数、内联函数、范围for循环、auto 与 nullptr 关键字

			
		

	





	

		

			

				
					
C++基础入门

				
			

			

				

					a577715979的博客
				

				

					01-02
					
					5679
					
				

			

		

		

			
				
C++入门

			
		

	





	

		

			

				
					
C++入门（一）

				
			

			

				

					weixin_53316121的博客
				

				

					05-02
					
					2785
					
				

			

		

		

			
				
初识C++


			
		

	





	

		

			

				
					
C++基础入门.pdf

				
			

			

				

					04-10
				

			

		

		

			
				
C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。  1. 创建项目...

			
		

	





	

		

			

				
					
c++初学入门

				
			

			

				

					02-06
				

			

		

		

			
				
c++语言入门基础知识,共计12个课题,第一课题：c++语言的基本框架 第二课题：c++语言的基本数据类型表达式 第三课题：c++语言的基本语句及顺序结构的程序设计 第四课题：c++语言的控制结构选择结构的程序设计 第五...

			
		

	





	

		

			

				
					
C++入门编程100题

				
			

			

				

					06-30
				

			

		

		

			
				
《C++入门编程100题》课程是由WangTeacher精心制作一部视频教学实战课程，初步计划100个编程题目的详细讲解，从简单到复杂的顺序排列。并结合15+年的软件开发经验，把最先进的软件开发流程和编程技巧融合到课程中，...

			
		

	





	

		

			

				
					
C++入门教程半成品C++入门教程半成品 

				
			

			

				

					04-06
				

			

		

		

			
				
C++入门教程半成品 C++入门教程半成品 C++入门教程半成品 C++入门教程半成品 C++入门教程半成品 C++入门教程半成品 C++入门教程半成品 C++入门教程半成品 C++入门教程半成品 C++入门教程半成品 C++入门教程半成品 ...

			
		

	





	

		

			

				
					
p4:cmu 15213/15513 csapp 深入理解计算机系统（寄存器、标志位/条件码、set指令、大端法小端法、逻辑左右移和算数左右移、字长概念）

				
			

			

				

					shanshan的博客
				

				

					11-11
					
					502
					
				

			

		

		

			
				
可以简单记成，setg表示set greater，但是机器指令的参数顺序与我们习惯的顺序不同，机器指令是从右到左比较的。标志位都是一位，他们不是你直接设置的，而是计算机的算术指令自己设置的。在这里是零拓展的意思，将al的一字节的全0拓展为4字节，左边都补0。综上，机器指令的流程是，比较两个数，得到一字节的0或1，然后根据返回类型的字长要求，拓展为相应位数的0或1。这里setg指令根据sf条件码，假设为0，（说明y>x），那么最低位的单个字节也都设为0。将单个寄存器的单个字节根据条件码的值设为1或0。

			
		

	





	

		

			

				
					
TI毫米波雷达（五）—— chirp

				
			

			

				

					slyywd的博客
				

				

					11-14
					
					987
					
				

			

		

		

			
				
TI的毫米波雷达可以通过定义chirp配置文件来控制一帧中的chirp参数，而且可以在chirp RAM中修改这些配置文件。Chirp配置文件可以作为基础的chirp时序模板，用来生成参数各异的chirp。TI的毫米波雷达可以接收四个不同的chirp配置文件，但是chirp可配置RAM中可以预编程512个独特的chirp。每个chirp都可以引用四个配置文件之一，然后按需要进行细调。一个帧由chirp可配置RAM中起始索引到结束索引间的chirp序列组成，最大可循环255次。

			
		

	





	

		

			

				
					
C++ 中的string类

					
最新发布

				
			

			

				

					2201_75357870的博客
				

				

					11-15
					
					694
					
				

			

		

		

			
				
end获得的不是最后一个字符的位置，而是最后一个字符的下一个位置！end()-1才是最后一个字符的位置。

			
		

	





	

		

			

				
					
STL之vecor的使用(超详解)

				
			

			

				

					2302_80220709的博客
				

				

					11-11
					
					783
					
				

			

		

		

			
				
如果发生的异地扩容，这时的迭代器就不在指向原来的空间，而就指向一块释放的内存，我们一旦继续访问就会报错，这种现象我们称为迭代器失效。指定位置插入，要注意的是这里不再像string一样，用的size_t 的pos，vector虽然也可以用下标访问，但是为了承接后面STL其他不支持下标访问的容器，所以这边的pos用的是迭代器类型。下面我们开始研究他的使用，为了能够更好的测试，我们先实现一个打印容器元素的函数，vector底层是数组，所以有三种访问方式：下标访问、迭代器访问、范围for（本质也是迭代器）

			
		

	





	

		

			

				
					
C++ 编程基础（5）类与对象 | 5.7、友元

				
			

			

				

					个人技术博客
				

				

					11-14
					
					1006
					
				

			

		

		

			
				
C++中的友元类与友元函数是一种强大的工具，它们允许程序员在保持类封装性的同时，实现对类内部数据的直接访问。然而，在使用时应谨慎考虑其对封装性、安全性和维护性的影响。只有在确实需要时才使用友元类和友元函数，以避免引入不必要的复杂性和潜在问题。

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 3

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
妖精七七_

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值