目录
一、作用域运算符(::)
1、符号 ::
2、作用
2.1 当局部变量和全局变量重名时,区分局部变量与全局变量
变量名 局部变量
::变量名 全局变量
2.2 指明使用的变量所属的命名空间
命名空间::变量名
2.3 实现函数的声明与定义分离
2.3.1 函数的声明
namespace E{
void method01();
}
2.3.2 函数的定义(实现)
void E::method01() {
//函数体
}
如:C中代码
#include <stdio.h>
int num = 10;
int main(int argc, char const *argv[])
{
int num = 20;
printf("局部变量num = %d\n",num);
//在c语言中当局部变量与全局变量重名时,因为就近原则,默认使用的是局部变量
//此时无法使用全局变量
return 0;
}
C++代码
#include <iostream>
using namespace std;
int num = 10;
int main(int argc, char const *argv[])
{
int num = 20;
cout << "局部变量 num = " << num << endl;
cout << "全局变量 num = " << ::num << endl;
return 0;
}
二、namespace 和 using
1、namespace(命名空间)
1.1 作用:
避免命名冲突、提高代码的可读性和可维护性、模块化管理代码、避免全局变量的污染。
1.2 语法:
namespace 空间名
{
// 变量
// 函数
}
1.3 使用(C++):
- 命名空间只能在全局范围内定义(必须定义在函数外)。
#include <iostream>
using namespace std;
namespace A{
int a = 1;
float b = 1.1;
char c = 'A';
}
int main()
{
cout << "A a = " << A::a << endl;
cout << "A b = " << A::b << endl;
cout << "A c = " << A::c << endl;
return 0;
}
- 命名空间可嵌套命名空间。
#include <iostream>
using namespace std;
namespace B{
int a = 2;
namespace C{
float b = 23;
char c = 'A';
}
}
int main()
{
cout << "B a = " << B::a << endl;
cout << "B C b = " << B::C::a << endl;
cout << "B C a = " << B::C::b << endl;
return 0;
}
- 命名空间是开放的,可以随时把新的成员加入已有命名空间中,但不能再次定义相同的变量。
#include <iostream>
using namespace std;
namespace A{
int a = 1;
float b = 1.1;
char c = 'A';
}
namespace A{
int d = 3;
float e = 'E';
namespace B{
int b = 33;
}
}
int main()
{
cout << "A a = " << A::a << endl;
cout << "A b = " << A::b << endl;
cout << "A c = " << A::c << endl;
cout << "A d = " << A::d << endl;
cout << "A e = " << A::e << endl;
cout << "A B b = " << A::B::b << endl;
return 0;
}
- 命名空间中可以定义函数,声明和实现可分离。
#include <iostream>
using namespace std;
namespace D{
void add()
{
cout << "A a + A b = " << A::a+A::b << endl;
}
void div();
}
void D::div()
{
cout << "A a - A b = " << A::a-A::b << endl;
}
int main()
{
D::add();
D::div();
return 0;
}
- 无名命名空间,意味着命名空间中的标识符只能在本文件内访问。
#include <iostream>
using namespace std;
namespace {
int a = 6;
}
int main()
{
cout << " a = " << ::a << endl;
return 0;
}
- 命名空间别名,在main函数中改名字,新名字在前,旧名字在后。
#include <iostream>
using namespace std;
namespace E{
int a=98;
}
int main()
{
namespace E1 = E;
cout << "E a = " << E::a << endl;
cout << "E1 a = " << E1::a << endl;
return 0;
}
2.using(引入命名空间、类型别名、资源管理)
2.1 语法:
- 声明命名空间中单个变量
using 命名空间名::变量名;
- 声明命名空间中单个函数
using 命名空间名::函数名;
- 声明整个命名空间
using namespace 命名空间名;
2.2 实例:
#include <iostream>
using namespace std;
namespace A{
int i = 10;
char c = 'A';
void methodA()
{
cout << "methodA" << endl;
}
}
//声明命名空间中的单个变量
//声明后在使用该变量就可以直接使用
using A::i;
//声明命名空间中的单个函数
//声明后在使用该函数就可以直接使用
using A::methodA;
//声明整个命名空间
//声明后整个命名空间中所有内容都可直接使用
using namespace A;
int main(int argc, char const *argv[])
{
cout << "A i = " << A::i << endl; // 10
cout << "A i = " << i << endl; // 10
methodA(); // methodA
cout << "A c = " << c << endl; // A
return 0;
}
2.3 注意:
using遇到函数重载,using 声明时 只声明了这个重载函数(下文有详解)的所有集合。使用 using 声明或 using 编译指令会增加命名冲突的可能性。
三、全局变量检测增强
实例:
C语言代码
#include <stdio.h>
int a;//c语言编译器会认为此处为变量的声明
int a;
int a = 10;//变量的定义与初始化
int main(int argc, char const *argv[])
{
return 0;
}
C++代码
#include <iostream>
using namespace std;
int a;//c++编译器将此处理解为变量的定义
//int a = 10;//此时将会重复定义,程序无法编译通过
int main(int argc, char const *argv[])
{
return 0;
}
四、输入输出(cin、cout)
cin 和 cout 是c++的标准输入流和输出流。它们是在头文件iostream中定义的。
cin 和 cout 是类对象,scanf 和 printf 是函数。
五、函数重载
1、含义
重载是多态的一种体现。
其函数名相同,形参列表不同。
返回值类型不同不能构成重载。
2、好处
可以根据不同的参数情况调用相应的函数,增加了代码的灵活性和可读性,避免了为不同参数类型或数量的操作取不同的函数名,使得代码更加简洁和易于维护。例如,在 C++ 中,可以有多个同名的函数用于对不同类型的数据进行加法运算。
3、易混(重载与重写)
重写:在子类中重新定义父类中已有的函数。子类中的重写函数与父类中的被重写函数具有相同的函数名、形参列表和返回类型。
| 重载 | 重写 | |
| 定义 | 函数名相同,形参列表不同 | 在子类中重新定义父类中已有的函数 |
| 发生范围 | 同一个类 | 子类和父类之间 |
| 规则要求 | 方法名相同,参数列表不同,返回类型可同可不同 | 方法名、参数列表和返回类型与父类被重写函数完全相同,访问权限不能更严格,不能抛出更多异常 |
| 调用方式 | 编译时根据参数确定调用哪个函数 | 运行时根据对象实际类型决定调用子类重写函数还是父类原始函数 |
| 作用目的 | 提供不同操作方式,增加代码灵活性和可读性 | 实现多态性,子类个性化实现父类函数 |
六、类型增强
1、C++中所有变量和函数都必须有类型
C代码:
#include <stdio.h>
void fun(i)
{
printf("fun\n");
}
void fun02()
{
printf("fun02\n");
}
int main(int argc, char const *argv[])
{
fun(10);
fun02();
return 0;
}
C++代码:
#include <iostream>
using namespace std;
//c++中变量必须有类型,此时i没有类型所有无法编译通过
// void fun(i)
// {
//
// }
//形参中的void表示没有形参列表
void fun02(void)
{
cout << "fun02\n";
}
int main(int argc, char const *argv[])
{
fun02();
return 0;
}
2、更严格的类型转换
C代码:(不用强转,编译通过)
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
int *nums = calloc(10,sizeof(int)); // 不用强转
return 0;
}
C++代码:(必须使用强转,编译才可通过)
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(int argc, char const *argv[])
{
int *nums = (int *)calloc(10,sizeof(int)); // 强转类型
return 0;
}
3、结构体类增强
#include <iostream>
using namespace std;
struct Person{
char name[50];
int age;
void eat()
{
cout << name << "吃面条" << endl;
}
void game();
};
void Person::game()
{
cout << name << "玩游戏" << endl;
}
int main(int argc, char const *argv[])
{
//c语法
struct Person p1 = {"tom",18};
//c++语法,定义结构体变量时可以不用写struct关键字
Person p2 = {"jek",18};
p1.eat();
p2.eat();
p1.game();
return 0;
}
4、新增bool类型
4.1 关键字
bool 类型赋值时,非 0 值会自动转换为 true(1), 0 值会自动转换 false(0) 。
| bool | 数据类型 |
| true(1) | 真 |
| false(0) | 假 |
4.2 注意
c 语言中也有 bool 类型,在 c99 标准之前是没有 bool 关键字,c99 标准已经有 bool 类型,包含头文件 stdbool.h,就可以使用和 c++一样的 bool 类型。
4.3 示例
#include <iostream>
using namespace std;
int main(int argc, char const *argv[])
{
cout << true + 0 << endl;
cout << false + 0 << endl;
bool tag = true;
tag = false;
tag = 10;
cout << tag << endl;
return 0;
}
5、const
5.1 全局变量
C代码:(会出现段错误)
const修饰的变量不能重新赋值也无法修改,因为num的值存储在常量区。
#include <stdio.h>
const int num = 10;
int main(int argc, char const *argv[])
{
//const修饰的变量不能重新赋值
//num = 1;
//无法进行修改,因为num的值存储在常量区
int *p = #
*p = 1;
printf("num = %d\n",num);
printf("*p = %d\n",*p);
return 0;
}
C++代码:(出现段错误)
#include <iostream>
using namespace std;
const int num = 10;
int main(int argc, char const *argv[])
{
//num = 1;
int *p = (int *) #
*p = 1;
cout << "num = " << num << endl;
cout << "*p = " << *p << endl;
return 0;
}
示例:
#include <iostream>
using namespace std;
struct Person
{
int age;
};
const Person p = {2};
int main(int argc, char const *argv[])
{
Person *p1 = (Person *)&p;
p1->age = 10;
cout << "p.age = " << p.age << endl;
return 0;
}
5.2 局部变量
C语言:
const修饰的变量不能重新赋值,但可以进行修改,因为num的值存储在栈区。
修改完成后num的值也将被修改。
#include <stdio.h>
int main(int argc, char const *argv[])
{
const int num = 10;
//const修饰的变量不能重新赋值
//num = 1;
//可以进行修改,因为num的值存储在栈区
int *p = #
*p = 1;
//修改完成后num的值也将被修改
printf("num = %d\n",num);
printf("*p = %d\n",*p);
return 0;
}
C++代码:
#include <iostream>
using namespace std;
int main(int argc, char const *argv[])
{
//在c++中const修饰的变量会存储在常量表中
const int num = 10;
//num = 1;
//当我们对常量表的中的变量区地址时,系统会开辟一片内存,使其存储其变量的值
int *p = (int *) #
//此时使用指针对其修改,修改的是新开辟的内存中的值
*p = 1;
//此时num的值依旧从常量表中获取,值并没有发生改变
cout << "num = " << num << endl;
cout << "*p = " << *p << endl;
return 0;
}
#include <iostream>
using namespace std;
int main(int argc, char const *argv[])
{
int a = 10;
//在c++中const修饰的变量以其他变量初始化,会为其分配内存空间
const int num = a;
//num = 1;
int *p = (int *) #
*p = 1;
//此时num的值依旧从常量表中获取,值发生改变
cout << "num = " << num << endl;
cout << "*p = " << *p << endl;
return 0;
}
#include <iostream>
using namespace std;
struct Person
{
int age;
};
int main(int argc, char const *argv[])
{
const Person p = {2};
//const修饰自定义类型的变量,无法修改其自定义变量中的成员变量
//p.age = 10;
//无法获取其成员变量的地址
//int *p = &(p.age);
//const修饰的自定义类型的变量,无法获取其地址,因为地址是使用const 数据类型 *修饰的
//转换后就可以使用该指针修改其自定义类型中的成员变量
Person *p1 = (Person *)&p;
p1->age = 10;
cout << "p.age = " << p.age << endl;
return 0;
}
5.3 总结
全局变量:C/C++都会出现段错误。
局部变量:
- 如果const修饰的普通类型的变量,使用普通初始化。
如:const int a = 10;
此时会生成符号常量表,当获取其变量地址时会开辟新的地址,使用新地址修改其
值,不会影响符号常量表中的值。
- 如果const修饰的普通类型的变量,使用变量初始化。
如:int x = 10;
const int a = x;
此时不会生成符号常量表,直接开辟地址,对当前地址的值进行修改,会改变其内容。
- 如果const修饰的是自定义变量。
- 无法直接修改其自定义类型中的成员变量。
- 无法获取自定义类型中的成员变量地址。
- 获取其自定义类型变量的地址需强转,强制过后就可以使用该地址修改其成员变量的值。
6、三目运算符增强
C语言:
因为C语言中的三目返回的是值,不是变量,因此它不能作为左值,否则无法通过编译。
#include <stdio.h>
int main(int argc, char const *argv[])
{
int a = 10;
int b = 1;
//c语言中三目返回的是值,不是变量
int c = a > b ? a : b;
//所以三目在c中不能作为左值,无法通过编译
(a > b ? a : b) = 100;
return 0;
}
C++:
返回的是变量,可以作为左值。
#include <iostream>
using namespace std;
int main(int argc, char const *argv[])
{
int a = 10;
int b = 1;
//c++中三目返回的是变量,不是值
int c = a > b ? a : b;
//所以三目在c++中可以作为左值
(a > b ? a : b) = 100;
cout << "a = " << a << endl;
return 0;
}
七、引用
1、符号 &
2、作用
给已有变量起别名。
3、语法
- 基本数据类型
数据类型 &变量名A = 变量名B;
给变量B取别名叫变量A(此时操作A就是在操作B,操作B也是在操作A)
- 数组类型
方式1:
typedef 数组的数据类型 类型别名[数组长度];
类型别名 &别名 = 数组名;
方式2:
数组的数据类型 (&别名)[数组长度] = 数组名;
注意:数组长度不能忽略不写。
- 指针
数据类型 *&别名 = 指针变量名;
- 常量
const 数据类型 &别名 = 变量名;
4、注意
- 不能返回局部变量的引用
- 函数当左值,必须返回引用。
- 引用的本质在 c++内部实现是一个指针常量。(Type& ref = val; // Type* const ref = &val;)
5、代码示例
#include <iostream>
using namespace std;
struct Stu
{
int age;
};
// void test(Stu s)
// {
// s.age = 10;
// }
void test(Stu &s)
{
s.age = 10;
}
int main(int argc, char const *argv[])
{
Stu stu = {1};
test(stu);
cout << "stu.age = " << stu.age << endl;
return 0;
}
八、内联函数(inline)***
1、语法
inline 返回值类型 函数名(形参列表)
{
// 函数体
}
2、特点
- 内联函数在编译阶段像宏一样展开。
- 作为类的成员函数,有作用域的限制。
-
内联函数为了继承宏函数的效率,没有函数调用时开销,然后又可以像普通函数那样,可以进行参数,返回值类型的安全检查,又可以作为成员函数。
3、注意
- inline 只能在定义函数时修饰。
- 任何在内部定义的函数自动成为内联函数。
- inline 修饰的函数是否为内联函数取决于编译器,对非inline修饰的函数,也有可能转换成内联函数(体积小、功能简单的函数)。
4、条件
- 不能存在任何形式的循环语句
- 不能存在过多的条件判断语句
- 函数体不能过于庞大
- 不能对函数进行取址操作
易混(内联函数与宏函数)(重要)
宏函数(带参宏):
参数没有类型,不能保证参数的完整性。
宏函数在预处理阶段展开。
宏函数没有作用域限制,不能作为类的成员。
内联函数:
参数有类型,保证参数的完整性。
内联函数在编译阶段展开。
内联函数有作用域限制,可以作为类的成员。
4740



被折叠的 条评论
为什么被折叠?



