day1 cpp:命名空间，const关键字，new/delete表达式

原创已于 2025-05-30 17:34:34 修改 · 819 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#开发语言

于 2025-05-19 21:25:58 首次发布

4.c++基础专栏收录该内容

7 篇文章

订阅专栏

1.前言

课程介绍

编程范式(编程思想)

c是面向过程的编程范式，c是面向对象的编程范式，比面向对象更抽象的是泛型编程范式

泛型编程范式是一种通过参数化类型来编写通用、可重用代码的方法，其核心在于将算法和数据结构与具体数据类型解耦

‌类型参数（Generics/Templates）‌
- 如C++模板template<typename T>或Java泛型<T>，允许在类、函数中使用占位符类型。
‌约束（Constraints）‌
- 通过接口（Java的extends）、概念（C++的requires）、或Trait（Rust的T: Ord）限制类型的行为。
‌代码复用‌
- 避免为不同类型重复编写逻辑相同的代码（如排序算法适用所有可比较类型）

应用领域

对时效性要求比较高的领域

书籍阅读

c++primer--初学者

c++程序设计语言

2.命名空间

为什么使用命名空间

c++为了避免命名冲突引入了命名空间，使其在不同的作用域中可以定义相同名字的变量

什么是命名空间

命名空间内可以存放变量，常量，结构体，引用，类，对象，模板，命名空间等，他们都称为实体

命名空间的使用

namespace wd {
	int num = 10;
	void print() {
		cout << "wd::print()" << endl;
	}
}//end of namespace wd
namespace wd2 {
	int num = 20;
	void print() {
		cout << "wd2::print()" << endl;
	}
}//end of namespace wd2

作用域限定方式

优点准确，缺点繁琐

// 作用域限定方式
void test0() {
	cout << wd::num << endl;
	cout << wd2::num << endl;
	wd::print();
	wd2::print();
}

using编译指令方式

1.using尽量放在局部作用域(放在全局可能会导致访问冲突)

2.若在一个函数中想同时访问wd::num和wd2::num，使用using编译指令方式做不到

3.这种方式使用命名空间中的实体时，要注意避免命名空间中实体与全局位置实体同名

//using编译指令方式
void test1() {
	using namespace wd;//放在局部
	cout << num << endl;
	print();
}

using声明机制方式

与using编译指令相比，若访问的局部作用域的using声明和全局变量名相同不会冲突，会遵循就近原则，但两者都解决不了在同一函数内访问wd::num和wd::num的问题

//using声明机制
void test2() {
	using wd::num;
	using wd::print;//只写函数名
	cout << num << endl;
	print();
}

匿名命名空间(只能作用域限定方式)

命名空间不定义名字称为匿名空间，匿名空间只能在本编译单元使用

namespace {
	int num = 10;
	void print() {
		cout << "::print()" << endl;
	}
}
void test0() {
	cout << ::num << endl;
	cout << ::print << endl;
}

跨模块调用

1.全局变量和函数是可以跨模块调用的

extern是声明，这时不会再重新开辟内存空间，而是去找已存在的这个名的空间

//extermA.cc
int num = 100;
void print() {
	cout << "print()" << endl;
}
//externB.cc
extern int num;//外部引用声明
extern void print();
void test0() {
	cout << num << endl;
	print();
}

2. 有名命名空间中的实体可以跨模块调用

//externA.cc
namespace wd {
	int num = 100;
	void print() {
		cout << "print()" << endl;
	}
}
//externB.cc
namespace wd {
	extern int num;
	extern void print();
}
void test0() {
	cout << wd::num << endl;
	wd::print();
}

使用命名空间的规则

在同一个源文件可以多次定义同名的命名空间，被认为是同一个命名空间，所以不能在其中定义相同的实体

命名空间中可以定义，声明实体，但不能访问实体

3.const关键字

const常量定义时必须初始化

修饰内置类型

常考面试题：const常量和宏定义常量区别？

1.发生的时机不同：

c中的宏定义发生时机在预处理时,做字符串替换；const常量是在编译时，是只读形式的变量

2.类型和安全检查不同：

宏定义没有类型，不做任何类型检查；const常量有具体的类型，在编译期会执行类型检查

修饰指针类型

void test0() {
	int num1 = 1;
	int num2 = 2;
	//可以修改指针的指向，但不能通过指针修改指向的值
	const int* p = &num1;//int const *p=&num1
	/* *p=100 error */
	p = &num2;
	//可以修改指针指向的值，但不可以修改指针的指向
	int* const p1 = &num1;
	/* p=&num2 error */
	*p1 = 100;
}

//函数指针
void print(int x) {
	cout << "print:" << x << endl;
}
void test() {
	//定义函数指针时要确定其指向函数的返回类型和参数信息
	void(*p)(int) = print;//名字代表代码块的地址
	p(6);
	void(*p1)(int) = &print;
	p1(7);
	
}
//指针函数
//函数的返回类型是指针类型
//返回的指针指向的内容生命周期要长于函数
int num = 100;
int* func() {
	int* p = &num;
	return p;//临时地址，不是p
}
void test0() {
	cout << *func() << endl;
}

4.new/delete表达式

c/c++内存堆申请和回收对比

void test() {
	int* p = (int*)malloc(sizeof(int));
	*p = 100;
	free(p);
	//4代表将堆上的int型变量初始化为4
	int* p1 = new int(4);
	delete p1;
	//()中没有值代表将堆上的变量初始化为该类型的默认值
	int* p2 = new int();
	delete p2;
	int* p3 = new int;//没有小括号，无法在所有平台上确保初始化
	delete p3;
}

valgrind工具(检查内存泄漏)

new表达式申请数组空间

void test1() {
	//开辟数组空间，其中每个元素被初始化为相应类型的默认值
	int* p = new int[5]();
	for (int i = 0; i < 5; i++) {
		p[i] = i;
	}
	for (int i = 0; i < 5; i++) {
		cout << p[i] << " ";
	}//0 1 2 3 4 
	
	int* p2 = new int[10]{ 1,2,3 };
	for (int i = 0; i < 10; i++) {
		cout << p2[i] << " ";
	}//1 2 3 0 0
}

//char * pstr=new char[6]{"hello"}; error 大括号中的数据应该是char类型
//c++中字符串是const char*
	char* pstr = new char[6]{ 'h','e','l','l','o' };
	delete[]pstr;

而上述赋值方式太麻烦，要一个个‘’，‘’，‘’ ，所以采用下列strcpy赋值方式

//在c++中使用c风格的字符串方式---(在c++中下面是const char*,在c中是char*)
	//故char* p1="hello";在c++中可能报错
	//所以c++中char*接收const char* 用strcpy赋值
	const char* p1 = "hello";
	cout << sizeof(p1) << endl;//4 or 8--指针的字节数
	cout << strlen(p1) << endl;//5
	char* ps = new char[strlen(p1) + 1]();
	strcpy(ps, p1);

cout << ps << endl;//hello
	for (int i = 0; i < 6; i++) {
		cout << ps[i] << " ";
	}//h e l l o
	delete[]ps;

为什么cout<<ps<<endl;输出的不是char *地址？

在c++中输出流运算符对char*有默认重载效果，

会自动访问指针地址指向的内容，

这里输出的不是地址而是地址指向的内容。

5.作业

const关键字和宏定义的区别是什么？

1.运行的阶段不同，宏定义在预处理阶段做字符串替换处理，const修饰的关键字在编译时进行处理
2.类型和安全性检查不同, 宏定义没有类型，只是在预处理阶段进行字符串的替换，也不会进行类型检查,const修饰的关键字会在运行时进行类型检查

2.new/delete与malloc/free的区别是什么？

区别:
1.malloc/free是库函数 new/delete是表达式
2.new表达式的返回值是相应类型的指针,malloc返回值是void*
3.malloc申请的空间不会初始化,获取的空间是有脏数据的,new申请的空间会自动初始化
4.malloc的参数是字节数,new表达式不需要传字节数,他会根据类型自动获取空间大小