C++基础知识点-CSDN博客

本文链接：https://blog.csdn.net/qq_74434275/article/details/131797615

由于主要攻克的语言是C++，之前有博客练习了面向对象的一些基本的内容接下来就开始介绍C++的一些基础语法的应用。

C++基础模板

#include<iostream>
using namespace std;
#define Day 7
int main()
{
	int a = 10;
    //流插入操作符
	cout << "一周总共有：" << Day << "天" << endl;
	cout << "Hello world" << '\n';
	cout << "a =" << a << endl;
    int i = 0;
    //流提取
    cin >> i;
	return 0;
}
//cout，cin能自动识别类型

C++命名空间

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

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

下面就是相关代码的实例：

#include<iostream>
#include<cstdlib>
//std是C++标准库的命名空间
using namespace std;
//大型项目不可全部展开
//命名空间：（可以定义）变量，结构，类，对象，函数
//对于C语言就是更换名字
namespace LinFu
{
	int rand = 0;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
	namespace xxx//也可以套娃
	{
		int rand = 1;
	}
}
//如果在另一个文件中定义LinFu的命名空间，命名空间会自动合并
using namespace LinFu;
//全部展开，命名空间，很危险，不推荐
using LinFu::Add;
//部分展开（授权），部分展开都有重名就不要展开
int main()
{
	printf("hello world\n");
	//域作用限定符::
	printf("%d\n", LinFu::rand);
	printf("%d\n", LinFu::xxx::rand);
	//默认情况是在全局进行查找，而不会去命名空间
	printf("%d\n", LinFu::Add(1, 2));
	printf("%d\n", Add(1, 2));//部分展开才可以使用
	struct LinFu::Node node;
	return 0;
}

引用

给变量起别名

语法：数据类型 &别名 = 原名

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

基本使用：

#include<iostream>
using namespace std;
int main()
{
 		//引用基本语法
        //数据类型 &别名 = 原名
        int a = 10;
        //创建引用
        int &b = a;
        
        cout << "a = " << a << endl; //10
        cour << "b = " << b << endl; //10
        b = 100;
        cout << "a = " << a << endl; //100
        cout << "b = " << b << endl; //100
    }
    return 0;
}

引用注意事项

引用必须初始化

引用在初始化之后就不可以再改变了

int main()
{
    int a = 10;
    int b = 20;
    //int &c; 错误，引用必须初始化
    int &c = a;//一旦初始化后，就不可以更改,只能改变a
    c = b;//这是赋值操作，不是更改引用
    cout << "a = "<< a << endl;
    cout << "b = "<< b << endl;
    cout << "c = "<< c << endl;
    cout << "d = "<< d << endl;
    return 0;
}

// 权限可以平移
// 权限可以缩小
// 权限不能放大
int func()
{
	int a = 0;
	return a;
}
int main()
{
    //int &ret = func();  会报错
	const int& ret = func();//临时对象拷贝具有常属性

    // 权限的放大---报错
    const int a = 0;
	// int& b = a;
	
	//int b = a; 可以的，因为这里是赋值拷贝，b修改不影响a

	// 权限的平移
	const int& c = a;

	// 权限的缩小
	int x = 0;
	const int& y = x;//正确

	int i = 0;
	const double& d = i;//正确

	return 0;
}

引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

示例：

//1.值传递
void mySwap01(int a,int b)
{
    int temp = a;
    a = b;
    b = temp;
}

//2.地址传递
void mySwap02(int*a,int*b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

//3.引用传递
void mySwap03(int &a, int &b)//相当于通过别名来进行修改
{
    int temp = a;
    a = b;
    b = temp;
}
int main()
{
    int a = 10;
    int b = 20;
    mySwap(a,b);
}

总结：通过引用参数产生的效果按地址传递是一样的，引用的语法更清楚简单

实例：

#include<iostream>
using namespace std;
typedef struct ListNode
{
	int data;
	struct ListNode* next;
}ListNode,*PlistNode;
//C语言的玩法
void LTPushbackc(ListNode** phead, int x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (*phead == NULL)
	{
		*phead = newnode;
	}
	else
	{
		//...
	}
}
//Cpp的玩法
void LTPushbackcpp(ListNode*& phead, int x)
//void LTPushbackcpp(PlistNode& phead, int x)//也有这种写法
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (phead == NULL)
	{
		phead = newnode;
	}
	else
	{
		//...
	}
}
void testc()
{
	ListNode* plist = NULL;
	LTPushbackc(&plist, 1);
	LTPushbackc(&plist, 2);
	LTPushbackc(&plist, 3);
}
void testcpp()
{
	ListNode* plist = NULL;
	LTPushbackcpp(plist, 1);
	LTPushbackcpp(plist, 2);
	LTPushbackcpp(plist, 3);
}
int main()
{
	testc();
	testcpp();
	return 0;
}

引用做函数参数的返回值

作用：引用时可以作为函数的返回值存在的

注意：不要返回局部变量引用

用法：函数调用作为左值

#include<iostream>
using namespace std;
int& test1()
{
	int a = 10;
	return a;
}
int& test2()
{
	static int a = 10;//静态变量，存在全局区，全局区上的数据在程序运行结束后系统释放
	return a;
}
int main()
{
	int& ref = test1();
	cout << "ref = " << ref << endl;  //第一次可能正确，因为编译器保留
	cout << "ref = " << ref << endl;  //但第二次就会报非法操作错误
	int& ref2 = test2();
	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;
	
    test2() = 1000;                   //如果函数的返回值是引用，这个函数调用可以作为左值
	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;
	return 0;
}

实例：

#include<iostream>
#include<assert.h>
using namespace std;
struct SeqList
{
	int a[10];
	int size;
};
//C的接口设计
//读取第i个位置的值
int SLAT(struct SeqList* ps, int i)
{
	assert(i < ps->size);
	// ...
	return ps->a[i];
}
//修改第i个位置的值
void SLModify(struct SeqList* ps, int i, int x)
{
	assert(i < ps->size);
	// ...
	ps->a[i] = x;
}
// CPP接口设计
// 读 or 修改第i个位置的值
int& SLAT(struct SeqList& ps, int i)
{
	assert(i < ps.size);
	// ...
	return (ps.a[i]);
}
int main()
{
	struct SeqList s;
	s.size = 3;
	// ...
	SLAT(s, 0) = 10;
	SLAT(s, 1) = 20;
	SLAT(s, 2) = 30;
	cout << SLAT(s, 0) << endl;
	cout << SLAT(s, 1) << endl;
	cout << SLAT(s, 2) << endl;
	return 0;
}

传引用传参（任何时候都可以用）

1、提高效率 2、输出型参数（形参的修改，影响的实参）

传引用返回（出了函数作用域对象还在才可以用）

1、提高效率 2、修改返回对象

引用的本质

本质：引用的本质在C++内部实现是一个指针常量

示例：

#include<iostream>
using namespace std;
//发现是引用，转换为int*const ref = &a;
void func(int& ref)
{
	ref = 100;//ref是引用，转换为*ref = 100
}
int main()
{
	int a = 10;
	//自动转化为int* const ref = &a;指针常量是指针指向不可改，也说明为什么引用不可更改
	int& ref = a;
	ref = 20;//内部发现ref是引用，自动帮我们转换为：*ref = 20;

	cout << "a :" << a << endl;
	cout << "ref: " << ref << endl;
	func(a);
	cout << "a :" << a << endl;
	return 0;
}

结论：C++推荐用引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了。

常量引用

作用：常量引用主要用来修饰形参，防止误操作

在参数形参列表中，可以加const修饰形参看，防止形参改变实参

示例：

#include<iostream>
using namespace std;
//打印数据函数
void showvalue(const int& val)
{
	//const int& val 后不可 val = 1000 进行修改
	cout << "val = " << val << endl;
}
int main()
{
	//常量引用
	//使用场景：用来修饰形参，防止
	int a = 10;
	int& ref = a;
	/*int& ref = 10;*/ //错误  //引用必须引一块合法的栈区或堆区的内存空间，而10是一个常量

	//加上const之后 编译器将代码修改 int temp = 10; const int &ref = temp;
	const int& ref = 10; 

	//ref = 20;  不可修改值，加入const之后变为只读，不可以修改
	int a = 100;
	showvalue(a);

	return 0;
}

C++的一些基础部分便总结完毕