【C++】入门基础（上）

云边有个稻草人

发布于 2024-10-21 20:03:20

11800

代码可运行

文章被收录于专栏：C++领域相关博客C++领域相关博客

运行总次数：0

代码可运行

1、C++入门小基础

1.1 祖师爷--Bjarne Stroustrup（本贾尼·斯特劳斯特卢普）

1.2 C++参考文献

参考资料 - C++ 参考资料 (cplusplus.com)

C++ 参考手册 - cppreference.com

cppreference.com

提示：第一个链接不是C++官方文档，标准也只是更新到C++11，但是以头文件形式呈现，内容比较易看好懂，后两个链接分别是C++官方文档的中文版和英文版，信息很全，更新到了最新的C++标准，没有第一个那么易看，各有优点，相互结合使用即可。

1.3 书籍推荐

《C++ Primer》：主要讲解语法，是一本经典的语法书籍，前中后期都可以看。

《STL源码剖析》：主要从底层实现的角度结合STL源码，庖丁解牛式剖析STL的实现。很好的帮助我们学习别人用语法是如何实现出简洁高效的数据结构和算法代码，如何使用泛型封装等。让我们不再坐井观天、闭门造车。建议中后期看。

《Effective C++》：这本书主要讲解了55个如何正确高效使用C++的条款，建议中后期看一遍，工作一两年后再看一遍，会有不一样的收获。

2、C++的第一个程序

C++兼容C语言绝大多数语法，所以C语言实现的hello world依旧可以运行，C++需要把定义文件代码后缀改成.cpp，vs编译器看到是.cpp就会调用C++编译器编译，linux下要用g++编译，不再是gcc。

C++也有一套自己的输入输出，严格说C++版本的hello world应该像下面这样写：

#include<iostream>
using namespace std;

int main()
{
	cout << "hello world" << endl;

	return 0;
}

3、命名空间

3.1 namespace的价值

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

C语言项目类似下面程序这样的命名冲突是普遍存在的问题，C++引入namespace就是为了更好的解决这样的问题。

#include<stdio.h>
#include<stdlib.h>

//文件在与预处理阶段会展开<stdlib.h>,里面包含以rand命名的函数，此时与我们定义的rand就会冲突

int rand = 100;
int main()
{
    printf("%d\n",rand);
    return 0;
}

3.2 namespace的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}，里面即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
namespace本质是定义出一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，同一个域不可以定义同名变量。所以下面的rand不再冲突了。
C++域中有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量/函数/类型出处（声明和定义）的逻辑，所以有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不会影响变量生命周期。
namespace只能定义在全局，不能定义在局部（例如不能在main函数里面定义）。当然它还可以嵌套定义使用，甚至多层嵌套。
项目工程中多文件中定义的同名namespace会认为是一个namespace，不会冲突。
C++标准库都放在一个叫std（standard）的命名空间。

#include<stdio.h>
#include<stdlib.h>

//1.正常的命名空间的定义

//lrq是命名空间的名字(我选的名字缩写)，一般开发者是用项目名字作命名空间名
namespace lrq
{
	//命名空间中可以定义变量/函数/类型
	int rand = 100;

	int Add(int left, int right)
	{
		return left + right;
	}

	struct Node
	{
		struct Node* next;
		int val;
	};
}

int main()
{
	//这里默认访问的是全局的rand函数指针
	printf("%p\n", rand);

	//这里指lrq命名空间里面的rand，::是域作用限定符，指定lrq空间里面的rand
	printf("%d\n", lrq::rand);
    lrq::Add(1,2);
    //注意这里::的位置
    struct lrq::Node node;

	return 0;
}

//2.命名空间可以嵌套
namespace lrq
{
	//1号
	namespace one
	{
		int rand = 99;

		int Add(int left, int right)
		{
			return left + right;
		}
	}

	//2号
	namespace two
	{
		int rand = 88;

		int Add(int left, int right)
		{
			return left * right;
		}
	}
}

int main()
{
	printf("%d\n", lrq::one::rand);99
	printf("%d\n", lrq::two::rand);88

	printf("%d\n", lrq::one::Add(1,2));相加
	printf("%d\n", lrq::two::Add(1,2));相乘

	return 0; 
}

//多文件中可以定义同名namespace，它们会默认合并到一起，就像同一个namespace一样


//不同的域可以定义同名变量，同一个域不可以定义同名变量

int x=1;

namespace lrq
{
    int x=2;
    return 0;
}

void func()
{
    int x=3;
}

int main()
{
    int x=4;

    printf("%d\n",x);//x=4
    printf("%d\n",lrq::x);//x=2
    printf("%d\n",::x);//此时默认访问的是全局的
    //无法访问func里面的。局部的只能在局部访问

    return 0;
}
//这里不会冲突，在main函数里面，默认到局部去找，再到全局去找，命名空间里面要指定去找x

3.3 命名空间的使用

编译查找一个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去找。所以下面程序会编译报错，。所以我们要使用命名空间中定义的变量/函数，有三种方式：

制定命名空间访问，项目中推荐这种方式；
using将命名空间中的某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式；
展开命名空间的全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

#include<stdio.h>

namespace lrq
{
	int a = 0;
	int b = 2;
}

int main()
{
	//编译报错，“a”：未声明的标识符
	printf("%d\n", a);

	//指定命名空间访问
	printf("%d\n", lrq::a);

	return 0;
}

//using将命名空间中的某个成员展开
using lrq::b;
int main()
{
	printf("%d\n", b);

	return 0;
}

//展开命名空间中的全部成员
using namespace lrq;
int main()
{
	printf("%d\n", a);
	printf("%d\n", b);

	return 0;
}

4、C++输入和输出

<iostream>是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
std::cin 是 istream 类的对象，它主要面向窄字符（narrow characters （of type char））的标准输入流。
std::cout 是 ostream 类的对象，它主要面向窄字符的标准输出流。（输入输出，字符串->整型等类型->字符流输出到终端）。
std::endl 是一个函数，流插入输出时，相当于插入一个换行字符加刷新缓冲区。
<<是流插入运算符，>>流提取运算符。（C语言还用这两个字符做位运算左移/右移）。
使用C++输入、输出更方便，不需要像 printf/ scanf 输入输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型（本质是通过函数重载实现的，这个后面讲解），其实最重要的是C++的流能更好的支持自定义类型对象的输入输出。
IO流涉及类和对象，运算符重载，继承等很多面向对象的知识，后面再详细学习介绍。
cout/ cin/ endl 等都属于C++标准库，C++标准库都放在一个叫std（standard）的命名空间中，所以要通过命名空间的方式去使用它们。
一般日常来练习中我们可以使用 using namespace std，实际项目开发中不建议 using namespace std。
这里我们没有包含 <stdio.h> 也可以使用 printf 和 scanf，在包含 <iostream> 就间接包含了<stdio.h>。VS系列编译器是这样的，其他编译器可能会报错。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

int main()
{
	int a = 0;
	double b = 100.0;
	char c = 'a';
    
    cout<<"hello world\n";//字符串后面加个\n，直接换行
    //支持连续的流插入，即使不同类型
	
	cout << a << " " << b << " " << c << " " << endl;//换行，推荐使用endl
	std::cout << a << " " << b << " " << c << " " << std::endl;//即使展开std，也可以写std::

	scanf("%d%lf", &a, &b);
	printf("%d %lf\n", a, b);//如果要求位数，推荐用printf

	//可以自动识别变量的类型
	cin >> a;
	cin >> b >> c;

	cout << a << endl;
	cout << b << " " << c << endl;

	return 0;
}

#include<iostream>
using namespace std;

//对于cout，流插入的东西不会直接到终端，而是先到一个缓冲区，有了刷新标志才会出现在终端

int main()
{
	//在io需求比较高的地方，如部分大量输入的竞赛题中，加上下面3行代码
	//可以提高C++IO效率
	ios_base::sync_with_stdio(false);//取消c和c++的兼容
	cin.tie(nullptr);
	cout.tie(nullptr);
    
    return 0;
}

5、缺省参数

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方也把缺省参数也叫默认参数）。
全缺省就是有多个形参，全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
带缺省参数的函数调用，C++规定必须从左往右依次给实参，不能跳跃给实参。
函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

【注意】 函数声明就是只有函数的返回值，名称和参数，简单理解就是没有{}的函数；函数定义就是函数带着实现{}。声明和定义只有一个地方可以有缺省值就比如： int add(int a, int b); int add(int a = 1, int b = 2) { return a+b; } 这个声明和定义只能有一个地方设置缺省值。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using namespace std;

void Func(int a = 0)
{
	cout << a << endl;
}

int main()
{
	Func();  //没有传参时，使用参数的默认值
	Func(10);//传参时，使用指定的实参

	return 0;
}

#include<iostream>
using namespace std;

//全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{

	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
	cout << "c= " << c << endl << endl;

}

//半缺省，缺省值必须要从右往左给

void Func2(int a, int b = 10, int c = 20)
{

	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
	cout << "c= " << c << endl << endl;

}

int main()
{
    //实参必须从左往右给

	Func1();//全部用缺省值
	Func1(1);//后两个用缺省值
	Func1(1, 2);
	Func1(1, 2, 3);//不使用缺省值
    Func1(,2,);//不支持这种

	Func2(100);
	Func2(100, 200);
	Func2(100, 200, 300);

	return 0;
	
}

//缺省参数的实际意义举例

//Stack.h
#include<iostream>
#include<assert.h>
using namespace std;

typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;
	int top;
	int capacity;
}ST;

void STInit(ST* ps, int n = 4);

//Stack.cpp
#incldue"stack.h"
//缺省参数不能声明和定义同时给

void STInit(ST* ps, int n)
{
	assert(ps && n > 0);

	ps->arr = (STDataType*)malloc(n * sizeof(STDataType));
	ps->top = 0;
	ps->capacity = 0;

}

//test.cpp
#incldue"Stack.h"
int main()
{
	ST s1;
	STInit(&s1);

	//确定知道要插入1000个数据，初始化一下开辟好，避免扩容
	ST s2;
	STInit(&s2,1000);

	return 0;
}

6、函数重载

C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数的个数不同或者类型不同。这样C++调用就出现了多态行为，使用更灵活。C语言是不支持同一作用域中出现同名函数的。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

//1、参数类型不同
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;

	return left + right;
}

double Add(double left, double right)
{
	cout << "int Add(double left, double right)" << endl;

	return left + right;
}

//2、参数个数不同
void f()
{
	cout << "f()" << endl;
}

void f(int a)
{
	cout << "f(int a)" << endl;
}

//3、参数类型顺序不同,本质还是参数类型不同
void f(int a, char b)
{
	cout << "f(int a, char b)" << endl;
}

void f(char a, int b)
{
	cout << "f(char a, int b)" << endl;
}

int main()
{
	Add(10, 20);
	Add(10.1, 20.2);

	f();
	f(10);

	f(10, 'a');
	f('a', 10);

	return 0;

}


//返回值不同不能作为重载条件，因为调用时也无法区分
void f()
{
	//...
}

int f()
{
	//...
	return 0;
}

//下面两个函数构成重载,参数不同
//f()但是调用时会报错，存在歧义，编译器不知道调用谁
void f1()
{
	cout << "f()" << endl;
}

void f1(int a = 10)
{
	cout << "f(int a)" << endl;
}

int main()
{
	f1();//没有参数
	f1();//没有传参，用缺省值
}

7、引用

7.1 引用的概念和定义

引用不是定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用一块内存空间。比如：马铃薯，也叫土豆。

类型& 引用别名=引用对象。

C++中为了避免引入太多运算符，会复用C语言的一些符号，比如前面的<<、>>，这里引用也和取地址操作符使用了同一个符号&。

【区分】 #define N 10（定义一个常量，在预处理阶段把N替换成10）； typedef 是给类型取别名；类型& 是给变量取别名。

#include<iostream>
using namespace std;

int main()
{
	int a = 0;

	//引用：b和c是a的别名
	int& b = a;
	int& c = a;
	//也可以给b取别名d，d也相当于是a的别名
	int& d = b;
    
    //这里a，b，c的值都会+1
	d++;

	//这里是取地址,取得都是一样的地址，因为它们共用一块内存空间
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &d << endl;

	return 0;
}

直观看出a,b,c,d之间的底层逻辑，见下图：

7.2 引用的特性

引用在定义时必须初始化；
一个变量可以有多个引用；
引用一旦引用一个实体，再不能引用其他实体。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

int main()
{
	int a = 10;

	//编译报错：“ra”：必须初始化引用
	//int& ra;

	int& b = a;
	int c = 20;
	//这里并非让b引用c，因为C++引用不能改变指向
	//这里是一个赋值
	b = c;

	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;

	return 0;

}

7.3 引用的使用

引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象；
引用传参和指针传参功能是类似的，引用传参相对方便一点；
引用返回值的场景相对比较复杂，后续再讲解；
引用和指针在实践中相辅相成，功能有重叠性，但各有特点，互相不可替代。C++的引用跟其他语言的引用（如Java）是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。
一些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目的是简化程序，避开复杂的指针。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>

using namespace std;

//这里rx，ry就相当于x和y的别名，不需要再传地址了
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;
}

#include<iostream>
using namespace std;
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST& rs, int n = 4)
{
	rs.a = (STDataType*)malloc(n * sizeof(STDataType));
	rs.top = 0;
	rs.capacity = n;
} 

// 栈顶
void STPush(ST& rs, STDataType x)
{
	// 满了， 扩容
	if (rs.top == rs.capacity)
	{
		printf("扩容\n");
		int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
		STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *
			sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		rs.a = tmp;
		rs.capacity = newcapacity;
	}
	rs.a[rs.top] = x;
	rs.top++;
}

// int STTop(ST & rs)
int& STTop(ST& rs)
{
	assert(rs.top > 0);
	return rs.a[rs.top];
}

int main()
{
	// 调⽤全局的
	ST st1;
	STInit(st1);
	STPush(st1, 1);
	STPush(st1, 2);
	cout << STTop(st1) << endl;

	STTop(st1) += 10;
	cout << STTop(st1) << endl;
	return 0;
}

#include<iostream>
using namespace std;
typedef struct SeqList
{
	int a[10];
	int size;
}SLT;

// ⼀些主要⽤C代码实现版本数据结构教材中，使⽤C++引⽤替代指针传参，⽬的是简化程序，避开复
//杂的指针，但是很多同学没学过引⽤，导致⼀头雾⽔。

void SeqPushBack(SLT& sl, int x)
{}
typedef struct ListNode
{
	int val;
	struct ListNode* next;
}LTNode, *PNode;
PNode就相当于typedef struct ListNode*;

// 指针变量也可以取别名，这⾥LTNode*& phead就是给指针变量plist取别名
// 这样就不需要⽤⼆级指针了，相对⽽⾔简化了程序
//void ListPushBack(LTNode** phead, int x)
//void ListPushBack(LTNode*& phead, int x)
void ListPushBack(PNode& phead, int x)
{
	PNode newnode = (PNode)malloc(sizeof(LTNode));
	newnode->val = x;
	newnode->next = NULL;
	if (phead == NULL)
	{
		phead = newnode;
	}
	else
	{
		//...
	}

}

int main()
{
	PNode plist = NULL;
	ListPushBack(plist, 1);
	return 0;
}

明天继续！

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-09-11，如有侵权请联系 cloudcommunity@tencent.com 删除

c++