C++入门基础

wwangxu2025-03-08 15:07

目录

  • [1. C++ 简介](#1. C++ 简介)
  • [2. Hello world!](#2. Hello world!)
  • [3. 命名空间](#3. 命名空间)
    • [3.1 namaspace](#3.1 namaspace)
    • [3.2 命名空间的使用](#3.2 命名空间的使用)
  • [4. C++输入&输出](#4. C++输入&输出)
  • [5. 缺省参数](#5. 缺省参数)
  • [6. 函数重载](#6. 函数重载)
  • [7. 引用](#7. 引用)
    • [7.1 引用的定义](#7.1 引用的定义)
    • [7.2 引用的特性](#7.2 引用的特性)
    • [7.3 引用的使用](#7.3 引用的使用)
    • [7.4 const引用](#7.4 const引用)
    • [7.5 指针和引用的关系](#7.5 指针和引用的关系)
  • [8. inline](#8. inline)
  • [9. nullptr](#9. nullptr)

正文开始

1. C++ 简介

C++是一种通用编程语言，支持面向对象编程（OOP）、泛型编程和函数式编程。他主要有以下特点：

  1. 兼容 C 语言：C++基于C语言，并扩展了面向对象的特性
  2. 面向对象编程（OOP）：支持类、继承、封装、多态等特性，提高了代码的复用性和可维护性。
  3. 泛型编程：提供模板，支持泛型函数和泛型类，增强代码通用性
  4. STL（标准模板库）：拥有标准模板库，包含常用的数据结构、算法和迭代器

相比于C语言，C++更加强大灵活，但也更复杂，广泛用于操作系统、游戏引擎、数据库管理系统、嵌入式开发、高性能计算等。

2. Hello world!

C++兼容C语言大多数的语法，所以 C 语言实现的程序依旧可以运行，C++中需要把定义文件代码后缀改为.cpp，编译器看到是.cpp就会调用C++编译器编译，linux下要用 g++ 编译，不再是 gcc。下面我们来简单看看第一个程序

cpp 复制代码 
// test.cpp
// 兼容C语言
#include <stdio.h>

int main(){
	printf("Hello world!\n");
	return 0;
}

当然C++有自己的一套输入输出：

cpp 复制代码 
// test.cpp
#include <iostream>
using namespace std;

int main(){
	cout << "Hello world!\n" << endl;
	return 0;
}

3. 命名空间

如果在同一个班里有很多叫小明的学生，这样会导致很多冲突，但将这些小明分散在不同班级里，这样就能很大程度上避免冲突。而 C/C++ 中的命名空间，就可以简单理解为一种把小明分散开的方式。

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

C语言项目中，像类似于下面这种程序所发生的命名冲突是普遍存在的，C++ 引入 namespace关键字来解决

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int rand = 2;
int main(){
	// 编译报错：error C2365："rand": 重定义；以前定义的是"函数"
	printf("%d\n",rand);
	return 0;
}

3.1 namaspace

大家先来见识一下namespace关键字是如何使用的：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

// 定义一个命名空间
// wx是命名空间的名字，一般开发中用项目名字做命名空间名
namespace wx{
	int rand = 10;
}

int main(){
	// 这里默认访问的是全局域中的rand函数指针
	printf("%p\n",rand);
	// 这里指定 wx 命名空间中的rand
	printf("%d\n",wx::rand);
	return 0;
}
  • 使用namespace关键字，本质上是定义出一个域，不用的域之间各自独立，不同的域可以定义同名变量
  • 定义命名空间，需要用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等
  • C++中域有函数局部域，全局域，命名空间域，类域 ；域影响的是编译时语法查找⼀个变量/函数/类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的⽣命周期，命名空间域和类域不影响变量⽣命周期
  • namespace 只能定义在全局
  • namespace 可以嵌套定义
  • 在同一个项目工程中多文件中定义的同名 namespace 会认为是同一个，不会冲突
  • C++标准库都放在一个叫std(standard)的命名空间中
cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include "test.h"


namespace wx_test1 {

	// 命名空间中可以定义变量/函数/类型等
	int rand = 10;

	int Add(int a, int b) {
		return a + b;
	}

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

namespace wx_test2 {
	// 命名空间可以嵌套
	namespace wx_test3 {
		int rand = 3;

		int Add(int a, int b) {
			return a + b;
		}
	}

	namespace wx_test4 {
		int rand = 4;

		int Add(int a, int b) {
			return a + b;
		}
	}
}

int main() {
	printf("%d\n", wx_test2::wx_test3::rand); // 3
	printf("%d\n", wx_test2::wx_test4::rand); // 4

	printf("%d\n", wx_test2::wx_test3::Add(1, 2)); // 3
	printf("%d\n", wx_test2::wx_test4::Add(1, 2)); // 3

	return 0;
}

3.2 命名空间的使用

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

  • 指定命名空间访问，项目中最常用方式
  • using 将命名空间中的某个成员展开，using声明是将命名空间中某个名字单独引入到当前作用域；项目中经常访问的不存在冲突的成员推荐这种方式
  • 展开命名空间中全部成员，在项目中不推荐使用，冲突风险大，日常练习的小程序为了方便推荐使用
cpp 复制代码 
#include <stdio.h>
namespace wx{
	int a = 0;
	int b = 1;
}

// 指定命名空间访问
int main(){
	printf("%d\n", wx::a); // 0
	return 0;
}

// using 将命名空间中某个成员展开
using wx::b;
int main(){
	printf("%d\n", wx::a); // 0
	printf("%d\n", b); // 1
	return 0;
}

// 展开命名空间中全部成员
using namespace wx;
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++中输入输出更为方便，不需要像printf/scanf那样手动指定格式，C++的输入输出可以自动识别变量类型（本质是通过函数重载实现的），最重要的是，C++的流能更好的支持自定义类型对象的输入输出
  • cout/cin/endl等都属于C++标准库，C++标准库都在一个叫std(standard)的命名空间中，所以要通过命名空间的方式使用它们。
  • 在vs编译器中包含iostream时，也间接的包括了stdio.h，所以同样也可以使用 printf 和 scanf；
cpp 复制代码 
#include <iostream>

using namespace std;

int main() {
	int a = 2;
	char b = 'x';
	double c = 0.3;
	
	// 输出
	cout << a << " " << b << " " << c << endl;
	
	// 输入
	cin >> a;
	cin >> b >> c;

	// 输出
	std::cout << a << " " << b << " " << c << std::endl;
	return 0;
}
cpp 复制代码 
#include<iostream>
using namespace std;
int main(){
	// 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码
	// 可以提⾼C++IO效率
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	return 0;
}

5. 缺省参数

我们可以通过缺省参数，来设定函数形参的默认值，当为传入实参时，使用形参的默认值。

  • 缺省参数是声明或定义函数时，为函数的参数指定一个缺省值。在调⽤该函数时，如果没有指定实参则采⽤该形参的缺省值，否则使⽤指定的实参，缺省参数分为全缺省和半缺省参数。
  • 全缺省就是全部 形参给缺省值，半缺省就是部分 形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
  • 带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参。
  • 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。
cpp 复制代码 
#include <iostream>
#include <assert.h>

using namespace std;

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

// 全缺省
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(){
	Func(); // 没有传参时，使⽤参数的默认值
	Func(10); // 传参时，使⽤指定的实参

	Func1();
	Func1(1);
	Func1(1,2);
	Func1(1,2,3);
	Func2(100);
	Func2(100, 200);
	Func2(100,200,300);
	
	return 0;
}

6. 函数重载

在 C语言中，如果我们想实现一个加法函数，我们可以这样写：

c 复制代码 
int Add(int a, int b){
	return a + b;
}

可是这样写会有一个很大的问题：我们只能计算两个整型类型的变量相加，那如果我想计算两个浮点数呢，就必须要重新再写一个不同名的函数：

c 复制代码 
double Add_double(double a, double b){
	return a + b;
}

这样的话，虽然能实现对应的功能，但是用户在使用时，终归不方便，还要去考虑传参的类型和对应的函数是什么，所以在C++中，引入了函数重载的概念，完美的解决了这个问题

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

cpp 复制代码 
#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 << "double 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 b, int a)
{
	cout << "f(char b, int a)" << endl;
}



// 返回值不同不能作为重载条件，因为调⽤时也⽆法区分
//void fxx()
//{}
//
//int fxx()
//{
// return 0;
//}
// 下⾯两个函数构成重载
// f()但是调⽤时，会报错，存在歧义，编译器不知道调⽤谁

void f1()
{
	cout << "f()" << endl;
}
void f1(int a = 10)
{
	cout << "f(int a)" << endl;
}
int main()
{
	Add(10, 20);
	Add(10.1, 20.2);
	f();
	f(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}

7. 引用

7.1 引用的定义

引用和指针很相似，C++中使用引用可以简化一些操作。

引用是给已存在的变量取了一个别名，并不是定义了一个新变量，编译器不会为引用变量开辟内存空间，它和它引用的变量公用同一块内存空间。比如一个人叫"王小明"，他妈妈叫他"明明"，他女朋友叫他"明宝"，而"明明"、"明宝"就是"王小明"的别名。

定义格式如下：

cpp 复制代码 
类型& 引用变量名 = 引用对象;

int main(){
	int a = 0;
	//类型& 引用变量名 = 引用对象;
	int& b = a;
	return 0;
}

C++中为了避免引入太多的运算符，会复用C语言的一些符号，比如前面的 << 和 >> ，这里引用也和取地址使用了同⼀个符号&，⼤家注意使用方法角度区分就可以。

cpp 复制代码 
#include <iostream>

using namespace std;

int main(){
	int a = 0;

	// 引用：b和c是a的别名
	int& b = a;
	int& c = a;

	// 也可以给别名b取别名，d相当于还是a的别名
	int& d = b;

	// 取地址并打印，发现都一样
	cout << &a << endl;
	cout << &b <<endl;
	cout << &c <<endl;
	cout << &d <<endl;
	
	return 0;
}

7.2 引用的特性

  • 引用在定义时必须初始化
  • 一个变量可以有多个引用
  • 引用一旦引用一个实体，再不能引用其他实体
cpp 复制代码 
#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的引用可以改变指向
cpp 复制代码 
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;
}

7.4 const引用

  • 可以引用⼀个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大
  • 在类型转换和计算表达式时，会创建一个临时对象来存储中间值，临时对象具有常性，是不能改变的，所以在引用临时对象时，需要用const修饰引用才可以。
  • 所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象，C++中把这个未命名对象叫做临时对象
cpp 复制代码 
int main()
{
	const int a = 10;
	// 编译报错：error C2440: "初始化": ⽆法从"const int"转换为"int &"
	// 这⾥的引⽤是对a访问权限的放⼤
	//int& ra = a;
	
	// 这样才可以
	const int& ra = a;
	// 编译报错：error C3892: "ra": 不能给常量赋值
	//ra++;
	
	// 这⾥的引⽤是对b访问权限的缩⼩
	int b = 20;
	const int& rb = b;
	// 编译报错：error C3892: "rb": 不能给常量赋值
	//rb++;
	
	return 0;
}
cpp 复制代码 
#include<iostream>

using namespace std;

int main()
{
	int a = 10;
	
	const int& ra = 30;
	
	// 编译报错: "初始化": ⽆法从"int"转换为"int &"
	// int& rb = a * 3;
	const int& rb = a*3;
	
	double d = 12.34;
	// 编译报错："初始化": ⽆法从"double"转换为"int &"
	// int& rd = d;
	
	const int& rd = d;
	
	return 0;
}

7.5 指针和引用的关系

  • 语法概念上引用是⼀个变量的取别名不开空间 ，指针是存储⼀个变量地址，要开空间
  • 引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的
  • 引用在初始化时引用⼀个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象
  • 引用可以直接访问指向对象，指针需要解引用才是访问指向对象
  • sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8字节)
  • 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全⼀些

8. inline

C语言中的宏函数实现很复杂也很容易出错，且不方便调试，所以在C++中设计了 inline 来代替C语言的宏函数；

  • 用 inline 修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就需要建立栈帧了，提高了函数调用的效率
  • inline 对于编译器而言只是一个建议，并不是一定会实现展开的功能，也就是说，如果加了 inline，编译器也可能会在调用的地方不展开，不同编译器关于 inline 在什么情况展开各不相同，C++标准并没有规定这个。
  • inline 适用于频繁调用的短小函数，对于递归函数、代码相对多一些的函数，加上 inline 也会被编译器忽略
  • vs 编译器的 debug 版本下默认是不展开 inline 的，这样更方便调试
  • inline 不建议声明和定义分离到两个文件，分离会导致连接错误，因为当 inline 被展开时没有函数的地址，链接时就会报错
cpp 复制代码 
#include <iostream>

using namespace std;

// 内联函数
inline int Add(int a, int b) {
	return a + b;
}

int main() {
	// 可通过汇编代码观察程序是否展开
	// 有call Add语句就是没有展开，没有就是展开了
	// call用于调用子程序，也就是这里的函数
	cout << Add(1, 3) << endl;
	return 0;
}
cpp 复制代码 
// test.h 
#inlcude <iosteam>
using namespace std;

intline int Add(int a , int b);

// test.cpp
#include "test.h"
int Add(int a , int b){
	return a + b;
}

// main.cpp
#include "test.h"
int main(){
	// 链接错误
	//Add(1,2);//error
	return 0;
}

9. nullptr

在C语言中，用NULL来表示空，在传统的C头文件(stddef.h)中，可以看到如下代码：

cpp 复制代码 
#ifndef NULL
	#ifdef __cplusplus	
		#define NULL 0
	#else
		#define NULL ((void *)0)
	#endif
#endif

也就是说，在C++中，NULL可能被定义为字面常量0，在C语言中被定义为无类型指针(void*)的常量；但不论是哪种情况，都不可避免地遇到一些问题，比如我们定义函数F(int*)和重载函数F(int)，当我们想要通过F(NULL)来调用F(int*)时，但是由于NULL被定义成了0，实际调用了F(int)，与使用者意愿相悖

  • C++11中引入了nullptr，一个特殊的关键字，nullptr 是一种特殊的字面量，它可以转换成任意其它类型的指针类型。使用 nullptr 定义空指针可以避免类型转换的问题，因为 nullptr 只能被隐式的转换为指针类型，而不能被转换为整数类型
cpp 复制代码 
#include <iostream>

using namespace std;

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

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

int main() {

	F(NULL); // 输出"F(int)"
	F((int*)NULL); // 输出"F(int*)"

	// 报错
	// 没有与参数列表匹配的 重载函数 "F" 实例
	// F((void*)NULL);

	F(nullptr); // 输出"F(int*)"

	return 0;
}

完

相关推荐
-凌凌漆-4 分钟前
【C#】async与await介绍
开发语言·c#
小猿_0014 分钟前
C语言单链表头插法
c语言·开发语言
Hello.Reader24 分钟前
在 Rust 中实现面向对象的状态模式
开发语言·rust·状态模式
JouJz26 分钟前
Java虚拟机之垃圾收集（一）
java·开发语言·jvm
五行星辰1 小时前
Java链接redis
java·开发语言·redis
邪恶的贝利亚1 小时前
C++之序列容器（vector,list,dueqe）
开发语言·c++
原来是猿1 小时前
蓝桥备赛（13）- 链表和 list（上）
开发语言·数据结构·c++·算法·链表·list
异常驯兽师1 小时前
Java集合框架深度解析：List、Set与Map的核心区别与应用指南
java·开发语言·list
成功助力英语中国话1 小时前
SDK编程，MFC编程，WTL编程之间的关系
c++·mfc
仟濹2 小时前
【算法 C/C++】二维差分
c语言·c++·算法
热门推荐
01DeepSeek各版本说明与优缺点分析02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03如何在WPS和Word/Excel中直接使用DeepSeek功能04苍穹外卖面试总结05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06本地部署DeepSeek教程（Mac版本）07DeepSeek本地部署详细指南08如何本地部署AI智能体平台，带你手搓一个AI Agent09保姆级教程：利用Ollama与Open-WebUI本地部署 DeedSeek-R1大模型10macOS 上部署 RAGFlow