#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int x = 0;
namespace zzy
{
int x = 1;
}
void func()
{
int x = 2;//局部域只能在当前局部访问
}
int main()
{
int x = 3;
printf("%d\n", x);//访问当前局部域
printf("%d\n", zzy::x);//访问命名空间域
printf("%d\n", ::x);//访问全局域
return 0;
}
namespace只能定义在全局，当然他还可以嵌套定义。
cpp复制代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
namespace 602
{
// zzy
namespace zzy
{
int rand = 1;
int Add(int left, int right)
{
return left + right;
}
}
// lkk
namespace lkk
{
int rand = 2;
int Add(int left, int right)
{
return (left + right) * 10;
}
}
}
int main()
{
printf("%d\n", bit::zzy::rand);
printf("%d\n", bit::lkk::rand);
printf("%d\n", bit::zzy::Add(1, 2));
printf("%d\n", bit::lkk::Add(1, 2));
return 0;
}
#include<stdio.h>
namespace zzy
{
int a = 0;
int b = 1;
}
int main()
{
// 编译报错：error C2065: "a": 未声明的标识符
printf("%d\n", a);
return 0;
}
所以我们要使⽤命名空间中定义的变量/函数，有三种⽅式：
指定命名空间访问，项⽬中推荐这种⽅式。
cpp复制代码
#include<stdio.h>
namespace zzy
{
int a = 0;
int b = 1;
}
// 指定命名空间访问
int main()
{
printf("%d\n", zzy::a);
return 0;
}
using将命名空间中某个成员展开，项⽬中经常访问的不存在冲突的成员推荐这种⽅式。
cpp复制代码
#include<stdio.h>
namespace zzy
{
int a = 0;
int b = 1;
}
// using将命名空间中某个成员展开
using zzy::b;
int main()
{
printf("%d\n", zzy::a);
printf("%d\n", b);
return 0;
}
展开命名空间中全部成员，项⽬不推荐，冲突⻛险很⼤，⽇常⼩练习程序为了⽅便推荐使⽤。
cpp复制代码
#include<stdio.h>
namespace zzy
{
int a = 0;
int b = 1;
}
// 展开命名空间中全部成员
using namespce zzy;
int main()
{
printf("%d\n", a);
printf("%d\n", b);
return 0;
}
#include <iostream>
using namespace std;
int main()
{
int a = 0;
double b = 0.1;
char c = 'x';
cout << a << " " << b << " " << c << endl;
std::cout << a << " " << b << " " << c << std::endl;
scanf("%d%lf", &a, &b);
printf("%d %lf\n", a, b);
// 可以⾃动识别变量的类型
cin >> a;
cin >> b >> c;
cout << a << endl;
cout << b << " " << c << endl;
return 0;
}
首先，和 C 语言不同的是，C++ 在进行输入输出时，并不需要像 C 语言那样在前面去定义诸如 "% s""% d" 这类格式化的标识。
然后关于输入输出的函数使用方面。我们在 C++ 中既可以使用 C 语言的 "scanf" 和 "printf" 函数来进行输入输出操作，不过使用这两个函数时需要指定数据类型。而 C++ 自身的输入输出操作就不用特意去指定类型了，使用起来更加便捷。另外，C 和 C++ 的输入输出函数是可以混合在一起使用的，并不会产生什么问题。但如果想要精准控制打印出来的小数点的精度，这里建议使用 "printf" 函数，因为在 C++ 中要控制这个精度的话，操作起来会相对麻烦一些。
提高效率
在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码可以提⾼C++IO效率
cpp复制代码
#include<iostream>
using namespace std;
int main()
{
// 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码
// 可以提⾼C++IO效率
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
return 0;
}
#include<iostream>
using namespace std;
struct A
{
int arr[1000];
};
void func(A& aa)
{
}
int main()
{
A aa1;
func(aa1);//传指针的话我们就直接传过去指针的4个字节
//如果将这个结构体传过去的话，那么就是4000个字节，我们需要额外进行拷贝的操作
//我们在这里使用引用的话，更方便些，同样和指针一样不需要进行额外的拷贝的操作
return 0;
}
取别名没有额外的开辟空间，通过应用的方式减少额外的拷贝：
cpp复制代码
#include<iostream>
using namespace std;
void Swap(int& rx, int& ry)
{
int tmp = rx;
rx = ry;
ry = tmp;
}
int main()
{
int x = 0, y = 1;
cout << x << " " << y << endl;
Swap(x, y);
cout << x << " " << y << endl;
return 0;
}
形参 rx 和 ry 分别是实参 x 和 y 的别名，那么对 rx 和 ry 进行交换操作，实际上就等同于对 x 和 y 进行交换操作。而且在这种情况下，当改变作为别名的引用对象时，与之对应的被引用对象也会随之改变。需要注意的是，这里通过指针其实也能够实现类似的功能，只是相比较而言，使用指针来达成此目的会更加麻烦一些。
引⽤传参跟指针传参功能是类似的，引⽤传参相对更⽅便⼀些。
以栈的尾插操作举例：
指针传参
cpp复制代码
#include <iostream>
using namespace std;
typedef struct ListNode {
int val;
struct ListNode* next;
} LTNode;
// 在链表末尾添加节点的函数
void ListPushBack(LTNode** phead, int x) {
LTNode* newNode = new LTNode;
newNode->val = x;
newNode->next = NULL;
if (*phead == NULL) {
// 如果链表为空，新节点就是头节点
*phead = newNode;
}
else {
LTNode* cur = *phead;
while (cur->next != NULL) {
cur = cur->next;
}
// 将新节点添加到链表末尾
cur->next = newNode;
}
}
int main() {
LTNode* plist = NULL;
ListPushBack(&plist, 1);
return 0;
}
引用传参
cpp复制代码
#include <iostream>
using namespace std;
typedef struct ListNode {
int val;
struct ListNode* next;
} LTNode, * PNode;
// 在链表末尾添加节点的函数
void ListPushBack(PNode& phead, int x) {
PNode newnode = (PNode)malloc(sizeof(LTNode));
newnode->val = x;
newnode->next = NULL;
if (phead == NULL) {
phead = newnode;
}
else {
PNode cur = phead;
while (cur->next != NULL) {
cur = cur->next;
}
cur->next = newnode;
}
}
int main() {
PNode plist = NULL;
ListPushBack(plist, 1);
return 0;
}
#include<iostream>
using namespace std;
int main()
{
// 权限不能放大
const int a = 10;
//在引用的过程中权限不能放大
//int& ra = a;
return 0;
}
我们先定义了一个常量 a，其声明方式为 const int a = 10;。由于 a 被定义成了常量，它是不能被修改的，所以也就不应该为它取别名。因为一旦为 a 取了别名，就存在对 a 进行修改的风险，这是不符合常量的不可修改特性的。
另外，在引用的操作过程中，有一个重要原则就是权限不能被放大 。就像这里如果写成 int& ra = a; 这种试图为常量 a 取引用别名的做法，实际上就是违背了权限不能放大的原则，因为这可能会导致意外修改常量 a 的值。
cpp复制代码
#include<iostream>
using namespace std;
int main()
{
// //权限可以缩小
int b = 1;
const int& rb = b;
//rb不能进行修改,b能被修改
//rb++;
b++;
return 0;
}
我们来看这样一种情况，即通过 const 来引用一个普通的对象。在这种情形下，是允许权限进行缩小操作的。比如，我们先定义了一个普通的整型变量 b，并将其初始化为 1，即 int b = 1;。然后，我们创建了一个常量引用 rb 来指向 b，声明语句为 const int& rb = b;这里要注意的是，通过 const 修饰的引用 rb 是不能进行修改操作的，而它所引用的原始对象 b 却依然可以被修改。例如，如果我们尝试对 rb 进行自增操作，像 rb++; 这样的语句是不被允许的，会导致编译错误。但对于原始变量 b，我们可以对其进行自增操作，如 b++; 是完全合法的。
cpp复制代码
#include<iostream>
using namespace std;
int main()
{
//不是权限的放大
//x不能修改，但是我们在下面将x拷贝成y
//我们修改y的话是对x没有影响的
const int x = 0;
int y = x;//这里是拷贝赋值
return 0;
}
这里要明确一点，并不是在进行权限的放大操作哦。我们先定义了一个常量 x，通过 const int x = 0; 这样的语句将其设定为不可修改的值，也就是 x 是不能被更改的。但是呢，接下来我们做了一个操作，就是把 x 拷贝给了 y，具体的语句是 int y = x;，这里其实就是在进行拷贝赋值啦。然后要知道的是，即便我们之后对 y 进行修改，那对于 x 来说也是没有任何影响的哦，因为它们之间只是进行了一次拷贝赋值的操作呀。
不需要注意的是类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样⼀些场景下a*3的和结果保存在⼀个临时对象中， int& rd = d 也是类似，在类型转换中会产⽣临时对象存储中间值，也就是时，rb和rd引⽤的都是临时对象，⽽C++规定临时对象具有常性，所以这⾥就触发了权限放⼤，必须要⽤常引⽤才可以。
cpp复制代码
#include<iostream>
using namespace std;
int main()
{
int a = 10;
const int& ra = 30;
// 编译报错: "初始化" :⽆法从"int"转换为"int& "
// int& rb = a * 3;
const int& rb = a * 3;
double d = 12.34;
// 编译报错："初始化" :⽆法"double"转换为"int& "
// int& rd = d;
const int& rd = d;
return 0;
}
#include <iostream>
// 定义一个内联函数，用于计算两个整数的和
inline int add(int a, int b) {
return a + b;
}
int main() {
int num1 = 5;
int num2 = 3;
// 调用内联函数add
int result = add(num1, num2);
std::cout << "两数之和为: " << result << std::endl;
return 0;
}
a，b，c，d几个别名，都可访问这个地址
