C++基础知识（一）

1. 命名空间：：

2. using 声明

3. 结构体加强

（1）不需要加struct就可以定义变量

1. 命名空间：：


namespace A{   //A 是空间的名字
    int a;
    void func()
    {}
}

（1）命名空间只能写在全局；

（2）可以嵌套；


namespace Aspace {  
    int a = 1;
    namespace B {
        int b;
    }
}

（3）命名空间是开放的，可以随时加入新成员；

（4）命名空间可以取别名；


namespace newSpace = oldSpace;
newSpace：新名字 
oldSpace：旧名字

（5）分文件编写代码时，如果.h中有两个命名空间，但是里边的成员函数或变量重名时，在.cpp中实现函数时需要加上命名空间。eg：

test.h：


#pragma once
#include <iostream>
using namespace std;
 
namespace Space1 
{
    void func();
}
 
namespace Space2
{
    void func();
}

test.c：


#include "test.h"
void Space1 :: func()  //需要在函数名之前加上命名空间的名字
{
    cout << "func" << endl;
}

（6）作用域运算符 ::

eg：


#include <iostream>
using namespace std;  //标准命名空间
 
namespace Aspace {   
    int aa = 1;
    void func()
    {
    }
    namespace B {
        int b = 3;
    }
}
 
namespace Cspace
{
    int c = 2 ;
}
 
 
int aa = 100;
 
int main()
{
    int aa = 10;
    cout << "aa =" << aa << endl;        //就近原则，打印局部变量aa的值
    cout << "::aa =" << ::aa << endl;    //如果::前边没有东西，则表示取全局的作用域，打印全局变量的aa
    cout << "Cspace::c =" << Cspace::c << endl;   //::前边加上命名空间的名字则打印命名空间中对应成员的值
    cout << "Aspace::B::b =" << Aspace::B::b << endl;
 
    system("pause");
    return EXIT_SUCCESS;
}

输出为：


aa =10
::aa =100
Cspace::c =2
Aspace::B::b =3

2. using 声明


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
 
namespace A {
	int a = 1;
	int b = 2;
	int c = 3;
}
 
void test01()
{
	//using声明是让命名空间中某个标识符可以直接使用
	using A::a;
	cout << a << endl;
 
	int a = 50; //错误，因为using声明了某个变量，在该作用域内不能定义同名的变量
}
 
void test02()
{
	//using 编译指令，让某个命名空间中的标识符都可以直接使用
	using namespace A;
	cout << a << endl;
 
	int a = 10; //这里没错，因为这里类似于命名空间中的a为全局变量，而这个a是局部变量
}

3. 结构体加强

（1）不需要加struct就可以定义变量


struct Maker
{
	char name[64];
	int age;
};
 
void test()
{
    Maker a;
}

（2）结构体内可以写函数


struct Maker2
{
	int a;
	void func()
	{
		cout << "func" << endl;
	}
};
 
void test()
{
    Maker2 a2;
    a2.func();
}

4. 不能进行隐式转换，必须是显式转换


void test()
{
	char* p = (char*)malloc(64);
}

5. 三目运算符

（1）C语言中，三目运算符返回的是右值，不能被赋值；


void test()
{
	int a = 10;
	int b = 20;
    printf("%d",a > b ? a : b);
	//(a > b ? a : b) = 100;  //err
}

（2）C++中，三目运算符返回的是左值，是空间，可以被赋值；


void test()
{
	int a = 10;
	int b = 20;
	(a > b ? a : b) = 100;  
    cout<<"a ="<<a<<endl;
    cout<<"b ="<<b<<endl;
}

输出为：


a=10;
b=100;

6. C/C++中的const

C	C++
const修饰的变量会被存储在只读数据段，只要有定义即分配内存空间	全局const当声明extern或者对变量取地址时，编译器才会分配存储地址，变量存储在只读数据段
局部const存储在堆栈区，不能直接改变变量的值，可以通过指针间接修改const的值	只有在分配了内存后，才能通过指针间接修改const变量的值。 ① 对于const int a = 10这种，编译器会进行优化，将a替换为10，类似于#define； ② 如果用一个变量初始化const，比如const int a = b，那么也会给a分配内存； ③ 对于类对象，也会分配内存，如下代码所示。
默认为外部连接，当两个c文件中都有同样的const变量时，编译器会报重定义错误	默认为内部连接，不会报重定义错误。如果想让C++中的const有外部链接，必须显式声明为：extern const int a = 10；


    const Person person; //未初始化age
	//person.age = 50; //不可修改
	Person* pPerson = (Person*)&person;
	//指针间接修改
	pPerson->age = 100;
	cout << "pPerson->age:" << pPerson->age << endl;

输出为：

pPerson->age:100

7. 引用（重难点）

（1）引用可以作为一个已定义变量的别名


void test02()
{
	int a = 10;
	int& b = a; //给a的空间取别名叫b
	b = 100;
	cout << a << endl;
}

输出为：100

而指针的写法是：


void test02()
{
	int a = 10;
	int* b = &a; 
	*b = 100;
}

（2）当定义函数时，按引用传递


void func(int &b)
{
    b = 100;
}
 
void test()
{
    int a = 10;
    func(a);
    cout << "a = " << a << endl;
}

输出为：a = 100

而C指针的写法是：


void func(int *b)
{
    *b = 100;
}
 
void test()
{
    int a = 10;
    func(&a);
    cout << "a = " << a << endl;
}

引用的注意：

① & 在此不是求地址运算，而是起标识作用；
② 引用创建时必须初始化；
③ 引用一旦初始化后不能改变它的指向
④ 必须引用一块合法的内存空间

（3）建立数组引用


int main()
{
	int arr[] = { 1,2,3 };
	//第一种方法
	typedef int(Arr)[3];  //定义数组类型
	Arr &arref = arr;     //建立引用
 
	//第二种方法,直接定义引用
	int(&arref2)[3] = arr;
 
	for (int i = 0; i < 3; i++)
	{
		cout << arref[i] << endl;
	}
}

（4）引用的本质

C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。


int main()
{
	int a = 10;
	int& aRef = a; //自动转换为int* const aRef = &a;这也能说明引用为什么必须初始化
	aRef = 20; //内部发现aRef是引用，自动帮我们转换为: *aRef = 20;
}

如下图所示：

（5）指针引用

在C语言中，如果想改变一个指针的指向，而不是它所指向的内容，则会使用二级指针，如下：


void func(char** tmp)
{
	char* p = (char*)malloc(64);
	memset(p, 0, 64);
	strcpy(p, "hello");
	*tmp = p;
}
 
void test()
{
	char* mp = NULL;
	func(&mp);
	cout << mp << endl;
}

改成引用的话：


void func(char* &tmp)
{
	char* p = (char*)malloc(64);
	memset(p, 0, 64);
	strcpy(p, "hello");
	tmp = p;
}
 
void test()
{
	char* mp = NULL;
	func(mp);
	cout << mp << endl;
}

（6）常量引用

定义格式：

const int& ref = val;


int main()
{
	//普通引用
	int a = 10;
	int& tmp = a;
	tmp = 20;
 
	//int &ref = 10;  err,不能给字面量取别名
	const int& tmp1 = 10;  //可以给const修饰的引用赋予字面量
	//编译器会把上边的代码变为：int x=10; const int &tmp1=x;
	//tmp2 = 20; err
}

（7）引用的使用

① 引用作为函数的参数


void func(int& a, int& b)
{
	int sum = a + b;
	cout << "sum = " << sum << endl;
}
 
void test()
{
	int a = 10;
	int b = 20;
	func(a, b);
}

② 引用作为函数的返回值

如果从函数中返回一个引用，必须像从函数中返回一个指针一样对待。当函数返回时，引用关联的内存一定要存在。


int& func()
{
	int b = 10;    //不能返回局部变量的引用
	int& p = b;
	return p;
}
 
int& func2()
{
	static int b = 10;
	return b;
}
 
void test()
{
	cout << "func=" << func() << endl;
	func() = 100;          //如果要函数当左值，那么该函数必须返回引用
	cout << "func2()=" << func2() << endl;
}

8. 内联函数

内联函数为了继承宏函数的效率，没有函数调用时的开销，又可以像普通函数那样，可以进行参数、返回值类型的安全检查，又可以作为成员函数。

内联函数也占用空间，但是相对于普通函数，只是省去了函数调用时的压栈、跳转、返回的开销，可以理解为内联函数是“以空间换时间”。

在普通函数前加上 inline 关键字使之成为内联函数。但是必须注意，函数体和声明结合在一起，否则编译器将它作为普通函数来对待。

inline void func(int a); //该写法没有任何效果

类内部的内联函数：

类内部定义内联函数时并不必须要加 inline，任何在类内部定义的函数自动成为内联函数。

c++内联编译会有一些限制：

不能存在任何形式的循环语句；
不能存在过多的条件判断语句；
函数体不能过于庞大；
不能对函数进行取址操作；

9. 函数的默认参数


int func(int a, int b = 0)  //b=0即为b的默认值
{
	return a + b;
}

注意：

函数的默认参数从左向右，如果一个参数设置了默认参数，那么这个参数之后的参数都必须设置默认参数。
函数声明和函数定义不能同时设置默认参数。

10. 函数的占位参数


void func(int a, int b, int)
{
	cout << "a+b = " << a + b << endl;
}
 
void func2(int a, int b, int=20)
{
	cout << "a+b = " << a + b << endl;
}
 
int main()
{
	func(10,20);     //err,占位参数也是参数，必须传参数
	func(10,20,30);  //ok
	func2(10,20);    //ok
	func2(10,20,30); //ok
 
	return EXIT_SUCCESS;
}

后边讲的操作符重载的后置++要用到这个。

11. 函数传参的三种方式

值传递、指针传递、引用传递


//值传递
void swap(int a, int b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
//指针传递
void swap2(int *a, int *b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
//引用传递
void swap3(int &a, int &b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
 
void myprint(int& a, int& b)
{
	cout << "a=" << a << "b=" << b << endl;
}
 
int main()
{
	int a = 10;
	int b = 20;
	swap(a,b);
	myprint(a, b);
	swap2(&a,&b);
	myprint(a, b);
	swap3(a,b);
	myprint(a,b);
}

上述三种交换结果，只有第一种值传递无法交换a，b的值。

12. 创建一个学生类


class Student
{
public:    //公有
	void setName(string Name)  //成员方法，也叫成员函数
	{
		name = Name;
	}
	void setID(int Id)
	{
		id = Id;
	}
	void myprint()
	{
		cout << "姓名：" << name << "\n学号：" << id << endl;
	}
private:  //私有权限
	string name;  //成员属性
	int id;
};
 
int main()
{
	Student s;
	s.setName("Paul");
	s.setID(1);
	s.myprint();
 
	system("pause");
	return EXIT_SUCCESS;
}

相关阅读:
如何选择合适的工业相机
 Java 时间的加减处理
 MATLAB中ilu函数用法
 计算机组成原理_Cache写策略
 linux 安装docker
大学生HTML作业节日网页 HTML作业节日文化网页期末作业 html+css+js节日网页 HTML学生节日介绍 HTML学生作业网页视频
 TypeScript进阶知识之接口(接口定义、接口属性、可索引类型、接口表示函数类型、额外的属性检查、接口继承、接口与类型别名的区别)
Kubernetes（K8s）上使用分布式存储（Distributed Storage）
【OS】操作系统高频面试题英文版(1)
FFmpeg5开发入门教程18：解码内存数据并播放
原文地址：https://blog.csdn.net/woshizuopie/article/details/124789854

C++基础知识（一）

1. 命名空间 ：：

2. using 声明

3. 结构体加强

（1）不需要加struct就可以定义变量

（2）结构体内可以写函数

4. 不能进行隐式转换，必须是显式转换

5. 三目运算符

6. C/C++中的const

7. 引用（重难点）

（1）引用可以作为一个已定义变量的别名

（2）当定义函数时，按引用传递

（3）建立数组引用

（4）引用的本质

（5）指针引用

（6）常量引用

（7）引用的使用

① 引用作为函数的参数

② 引用作为函数的返回值

8. 内联函数

9. 函数的默认参数

10. 函数的占位参数

11. 函数传参的三种方式

12. 创建一个学生类

1. 命名空间：：