学习笔记—C++—入门基础()

目录

C++介绍

参考文档

C++第一个程序

命名空间namespace

namespace的价值

namespace的定义

namespace使用

指定命名空间访问

using将命名空间中某个成员展开

展开命名空间中全部成员

输入和输出

缺省参数

函数重载

引用

引用的概念

应用

const引用

指针和引用的关系

inline

nullptr

---

C++介绍

“C++”是一种多功能的编程语言，它起源于1980年代初，由Bjarne Stroustrup在C语言的基础上发展而来。C++最初被设计为支持面向对象编程的C语言变体，后来经过多次迭代和标准化，发展成为一种广泛应用于系统软件、游戏开发、嵌入式系统等领域的语言。C++的发展经历了多个重要阶段，包括C++98、C++03、C++11、C++14、C++17、C++20和即将到来的C++23标准.

参考文档

Reference - C++ Reference

特点：通俗易懂                

https://zh.cppreference.com/w/cpp

特点：完整中文版

https://en.cppreference.com/w/

特点：完整英文版

C++第一个程序

// test.cpp
#include<iostream>
using namespace std;int main()
{cout << "hello world\n" << endl;return 0;
}

#include<iostream>是什么头文件

using namespace std;又是什么东西

打印“hello world”怎么变成了cout << "hello world\n" << endl;

命名空间namespace

namespace的价值

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

c语言项目类似下面程序这样的命名冲突是普遍存在的问题，C++引入namespace就是为了更好的解决 这样的问题。

#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
int rand = 10;
int main()
{// 编译报错：error C2365: “rand”: 重定义；以前的定义是“函数”printf("%d\n", rand);return 0;
}

当头文件只有stdio.h的时候是没有问题的，但是我们加上另一个头文件stdlib.h就会出现报错的现象，在stdlib这个库里面定义了一个rand 的函数，那么我们现在又在外面定义一个rand的变量，那么就会出现冲突。

namespace的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接⼀对{}即可，{}中 即为命名空间的成员。命名空间中可以定义变量/函数/类型等。

namespace wuguo
{// 命名空间中可以定义变量/函数/类型int rand = 10;int Add(int left, int right){return left + right;}struct Node{struct Node* next;int val;};
}

namespace本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下面的rand不在冲突了。

#include<stdio.h>
#include<stdlib.h>
#include<iostream>int rind = 10;namespace wuguo
{int rind = 30;
}int main()
{printf("%d\n", rind);          //打印的是全局的10printf("%d\n", wuguo::rind);   //打印的是wuguo域里的30return 0;
}

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

int x = 0;//全局域namespace bit
{int x = 10;//命名空间域
}void func()
{int x = 20;//局部域
}int main()
{int x = 30;//局部域printf("%d\n", x);      //这里默认访问的是局部的这个x，因为搜索是先局部再全局搜索。printf("%d\n", bit::x); //这里就是访问命名空间域printf("%d\n", ::x);    //这里就是访问全局变量。return 0;
}

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

// 命名空间可以嵌套
namespace wuguo
{// 小王namespace xw{int rand = 10;int Add(int left, int right){return left + right;}}// 大王namespace dw{int rand = 20;int Add(int left, int right){return (left + right) * 10;}}
}int main()
{printf("%d\n", wuguo::pg::rand);printf("%d\n", wuguo::hg::rand);printf("%d\n", wuguo::pg::Add(10, 20));printf("%d\n", wuguo::hg::Add(10, 20));return 0;
}

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

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

namespace使用

指定命名空间访问

namespace wuguo
{int a = 0;int b = 1;
}
int main()
{printf("%d\n", wuguo::a);return 0;
}

项目中推荐这种方式。

using将命名空间中某个成员展开

namespace wuguo
{int a = 0;int b = 1;
}
//把wuguo域里的a展开了
using wuguo::a;
int main()
{printf("%d\n", a);return 0;
}

项目中经常访问的不存在冲突的成员推荐这种方式。

展开命名空间中全部成员

namespace wuguo
{int a = 0;int b = 1;
}
using namespace wuguo;
int main()
{printf("%d\n", a);printf("%d\n", b);return 0;
}

项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

输入和输出

<iostream>是 Input Output Stream 的缩写，是标准的输⼊、输出流库，定义了标准的输⼊、输

出对象,就是他们的库函数。

std::cin 是istream类的对象，它主要面向窄字符（narrowcharacters(oftypechar)）的标准输入流，就是输入。

std::cout 是ostream类的对象，它主要面向窄字符的标准输出流，就是输出。

std::endl 是⼀个函数，流插⼊输出时，相当于插入⼀个换行字符加刷新缓冲区，就是换行。

<<是流插入运算符，>>是流提取运算符。

#include<iostream>
using namespace std;int main()
{// <<输出cout << "hello world\n";int i = 10;double d = 1.1;//>>输入cin >> i >> d;cout << i<<":"<<d << std::endl;return 0;
}

输入一个“整数” “空格” “小数”

输出“整数” “：” “小数”

缺省参数

缺省参数是一种便捷的机制，允许在函数声明时为参数指定默认值。如果在调用函数时省略了这些参数，编译器会自动使用它们的缺省值。使用缺省参数可以简化函数调用，减少冗余代码，并提高代码的可读性和灵活性。

全缺省参数：函数的所有参数都可以有缺省值，调用时可以不传递任何参数。
半缺省参数：只有部分参数有缺省值，这些缺省值必须从右向左依次指定，不能间断。
声明与定义分离：如果函数声明和定义分开，缺省参数只能在声明中指定，定义中不应再次指定。
缺省值的限制：缺省值必须是常量表达式或全局变量，不能是局部变量或动态分配的内存。
调用顺序：实参的传递顺序是从左向右，而形参的缺省值赋值顺序是从右向左。

#include <iostream>
#include <assert.h>
using namespace std;void Func(int a = 0)
{cout << a << endl;
}// 全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}// 半缺省
void Func2(int a, int b = 10, int c = 20)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}int main()
{Func(); // 没有传参时，使用参数的默认值Func(10); // 传参时，使用指定的实参Func1();                 //a=10 b=20  c=30Func1(1);                //a=1  b=20  c=30Func1(1, 2);             //a=1  b=2   c=30Func1(1, 2, 3);          //a=1  b=2   c=3// 不支持// Func1(,2,3);Func2(100);              //a=100 b=10  c=20Func2(100, 200);         //a=100 b=200 c=20Func2(100, 200, 300);    //a=100 b=200 c=300return 0;
}

函数重载

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

函数名称必须相同。

参数列表必须不同，这包括参数的个数、类型或顺序的不同。

返回类型不影响函数重载，即使两个函数的返回类型不同，它们也可以构成重载，因为重载决策是基于函数的参数列表进行的。

void ADD(int a, int b)
{cout << a + b << endl;
}void ADD(double a, int b)
{cout << a + b << endl;
}void ADD(int a, double b)
{cout << a + b << endl;
}int main()
{ADD(1, 1);ADD(1, 1.1);ADD(1.1, 1);return 0;
}

引用

引用的概念

在C++中，引用是一种特殊的变量类型，它提供了对另一个变量的别名。

引用在语法层面是不开辟空间的

在底层引用类似于指针变量是开辟空间

void Test()
{int a = 10;//定义引用类型ra就是a的别名，地址也是一样的int& ra = a;printf("%p\n", &a);printf("%p\n", &ra);
}​

应用

作为函数参数

//作为函数参数
​void Swap(int& left, int& right)
{int temp = left;left = right;right = temp;
}int main()
{int x = 0, y = 1;cout << x << " " << y << endl;Swap(x, y);cout << x << " " << y << endl;return 0;
}//传返回值
int& STTop(ST& rs)
{assert(rs.top > 0);return rs.a[rs.top];
}
STTop(st1)++;
​

易错示例

int& Add(int a, int b)
{int c = a + b;return c;
}
int main()
{int& ret = Add(1, 2);Add(3, 4);cout << "Add(1, 2) is :"<< ret <<endl;return 0;
}

这个代码将C的值返回，返回值是别名，当调用函数的时候，函数会建立栈帧，当调用结束的时候，这空间的随之就会返回给操作系统，C变量也就不会存在。输出是随机值。

const引用

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

int main()
{//a不能进行修改,所以不能取别名，取别名的话是会对a造成修改的风险的const int a = 10;//在引用的过程中权限不能放大//int& ra = a;//那么这里的ra就是const对象const int& ra = a;//cnost引用普通的对象//权限可以缩小int b = 1;//rb不能进行修改,b能被修改const int& rb = b;//rb++;b++;//x不能修改const int x = 0;//这里是拷贝赋值,所以可以修改y对x没有影响int y = x;return 0;
}

指针问题

int main()
{//a是不能进行修改的const int a = 10;//√p1固定指a不能被修改const int* p1 = &a;//×权限的放大int* p2 = p1;int b = 20;//√p3存的是b的地址int* p3 = &b;//√p4也是b的地址，只读不改const int* p4 = p3;return 0;
}

指针和引用的关系

C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。

• 语法概念上引用是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间。

• 引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。

• 引用在初始化时引用⼀个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。

• 引用可以直接访问指向对象，指针需要解引用才是访问指向对象。

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

• 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全⼀些。

inline

用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 << ret << endl;;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;
}

 inline对于编译器而言只是⼀个建议，也就是说，你加了inline编译器也可以选择在调用的地方不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。

inline适用于频繁调用的短小函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。

debug是默认不展开的，release是展开的

debug展开方式

展开了就没有栈帧的消耗，不展开就有，如果函数较长的话，就不展开了。

nullptr

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

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

C++中NULL可能被定义为字面常量0，或者C中被定义为无类型指针(void)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到⼀些麻烦，本想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，调用了f(int x)，因此与程序的初衷相悖。f((void*)NULL);调用会报错。

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

在c++中使用nullptr来定义空指针可以避免类型转换的问题

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*)0);f(nullptr);  //在c++中使用nullptr来定义空指针可以避免类型转换的问题return 0;
}