2026 前端新出路：掌握 C++ 核心语法，无缝衔接 QT 桌面开发

2026 前端新出路：掌握 C++ 核心语法，无缝衔接 QT 桌面开发

引言

以下只针对有C语言基础的开发人员查看哦，之前学习C语言的时候也有写过学习文章，https://wuyong.blog.csdn.net/article/details/140003033?spm=1011.2415.3001.5331

---

高级语言编译过程

---

输入输出

使用c++的输入输出的时候，必须在程序的开头增加一行#include <iostream.h>，即包含输入输出流的头文件iostream

#include <iostream>  // c++ 包含头文件输入输出流
using namespace std;

int main() { // 主函数 main有前面int主函数的返回值为整形
	int x = 0;
	cout << "\n 欢迎来到C++" << endl << endl;

	cout << "x = " << x << endl;

	// 从键盘输入x的值
	cout << "请输入x的值:";
	cin >> x;

	cout << "x = " << x << endl;
	return 0;
}

标准输出流

与输入cin对应的输出是count输出流

cout << "安徽省" << "阜阳市" << endl;

其中运算符<<成为插入运算符，它将紧跟其后的表达式的值，输出到显示器当前光标的位置，指定输出项占用的宽度，使用setw()函数，在程序的开始位置必须包含头文件iomanip.h，即在程序的开头添加:#include <iomanip.h>

---

内联函数

内联函数的实质是用存储空间（使用更多的存储空间）来换取时间（减少执行时间）。内联函数的定义方法是，在函数定义时，在函数的类型前增加修饰词inline。

---

重载函数

所谓函数的重载是指完成不同功能的函数可以具有相同的函数名。C++的编译器是根据函数的实参来确定应该调用哪一个函数的。

定义的重载函数必须具有不同的参数个数，或不同的参数类型。只有这样编译系统才有可能根据不同的参数去调用不同的重载函数。

仅返回值不同时，不能定义为重载函数。即仅函数的类型不同，不能定义为重载函数。

---

指针基础

系统根据程序中定义变量的类型，给变量分配一定的长度空间。字符型占1个字节，整型数占4个字节。内存区的每个字节都有编号，称之为地址。

---

直接访问

按变量地址存取变量的值。cin>>i; 实际上放到定义i单元的地址中。

间接访问

将变量的地址存放在另一个单元p中，通过 p 取出变量的地址，再针对变量操作。

一个变量的地址称为该变量的指针：如果在程序中定义了一个变量或数组，那么，这个变量或数组的地址（指针）也就确定为一个常量。

---

变量的指针和指向变量的指针变量

变量的指针就是变量的地址，当变量定义后，其指针（地址）是一常量。可以定义一个变量专门用来存放另一变量的地址，这种变量我们称之为指针变量。在编译时同样分配一定字节的存储单元，未赋初值时，该存储单元内的值是随机的。

1. 指针变量定义的一般形式为： 类型标识符 *变量名

int *i_point;

2. 指针变量同样也可以赋值

int  i,  *i_point;
i_point=&i;

3. 也可以在定义指针变量时赋初值：

int  i;
int   *i_point=&i;

一个指针变量只能指向同一类型的变量。即整型指针变量只能放整型数据的地址，而不能放其它类型数据的地址。

* 在定义语句中只表示变量的类型是指针，没有任何计算意义。

* 在语句中表示"指向"。&表示"地址"。

指针变量的引用

指针变量只能存放地址，不要将非地址数据赋给指针变量。

#include <iostream>  // c++ 包含头文件输入输出流
#include <iomanip>
using namespace std;

int main() { 
	int a = 20, b = 40;
	int* p = &a,* p2 = &b;
	cout << "a=" << a << ",b=" << b << endl;
	cout << "p=" << p << ",p2=" << p2 << endl;
	cout << "p=" << *p << ",p2=" << *p2 << endl;
	return 0;
}

++,--,*优先级

++, --, 优先级相同，都是右结合性。

(*p)++;  // 相当于a++。

*p++; 、*(p++)首先*p ，然后p=p+1,指针指向下一个int单元 表达式为3, p=2154H。

指针变量作为函数参数

函数的参数可以是指针类型，它的作用是将一个变量的地址传送到另一个函数中。指针变量作为函数参数与变量本身作函数参数不同，变量作函数参数传递的是具体值，而指针作函数参数传递的是内存的地址。

#include <iostream>  // c++ 包含头文件输入输出流
#include <iomanip>
using namespace std;

/*交换函数*/
void swapFunc(int* p1, int* p2) {
	int temp = 0;
	temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() { 
	int a, b, * p1, * p2;
	cout << "请输入a,b的值:";
	cin >> a >> b;

	cout << "a=" << a << "\nb=" << b << endl;
	p1 = &a;
	p2 = &b;
	if (a < b) {
		swapFunc(p1, p2);
		cout << "a=" << a << "\nb=" << b << endl;
		cout << "\n*p1=" << *p1 << "\n*p2=" << *p2 << endl;
	}
	return 0;
}

指向数组元素的指针变量定义与赋值

int a[10],*p;
p = &a[0]  // 数组第一个元素的地址;
p = a // 直接用数组名赋值

若数组元素为int型，则指向其的指针变量也应定义为int型。

int a[10];
int *p = a;
int *p = &a[0]

通过指针引用数组元素

int a[10];
int *p = a; // 为指针变量赋初值
*p = 1; // 通过指针变量为数组赋值
a[0] = 1;

c++规定，p+1指向数组的下一个元素，而不是下一个字节。

*(p+1) = 2; //  a[1] = 2;
*++p = 2; // p=p+1; *p = 2; p = 2004j，指针变量也重新赋值

#include <iostream>  // c++ 包含头文件输入输出流
#include <iomanip>
using namespace std;

int main() { 
	int a[5] = { 34,56,32,89,19 };
	int* pa = a;
	cout << "通过循环输出数组a元素:\n";

	for (int i = 0; i < 5; i++) {
		cout << *(pa + i) << ",";
	}
	cout << endl;
	cout << "\na[0]：" << *pa << endl; // 34
	*pa = 59;
	cout << "a[0]：" << *pa << endl;  // 59
	cout << "结果："<< *(pa + 1) << endl;  // 56

	return 0;
}

---

指针引用

对变量起另外一个名字，这个名字称为该变量的引用。

<类型> &<引用变量名> = <原变量名>

其中原变量名必须是一个一定义过的变量。

int max;
int &refmax = max;

refmax并没有重新再内存单元中开辟单元，只是引用max的单元，max与refmax在内存中占用同一地址，即同一地址两个名字。

#include <iostream>  // c++ 包含头文件输入输出流
#include <iomanip>
using namespace std;
int main() { 
	int max;
	int& refmax = max;
	max = 5;
	refmax = 10;
	cout << "max = " << max <<"，refmax = "<< refmax <<endl;
	cout << "max地址 = " << &max << "，refmax地址 = " << &refmax << endl;
	refmax = max + refmax;
	cout << "max地址 = " << &max << "，refmax地址 = " << &refmax << endl;
	cout << "max = " << max << "，refmax = " << refmax << endl;
	return 0;
}

引用类型的变量说明：

1. 引用在定义的时候要初始化。

   int& refmax;  // 错误：没有具体的引用对象

2. 对引用的操作就是对被引用的变量的操作。

3. 引用类型变量的初始化值不能是一个常数。

   int &ref1 = 5; // 错误

4. 引用同变量一样有地址，也可以对其地址进行操作，即将其地址赋给一指针。

   #include <iostream>  // c++ 包含头文件输入输出流
   #include <iomanip>
   using namespace std;
   int main() { 
   	int a, * p;
   	int& m = a;  // &是变量的引用
   	p = &m;   // &是变量的地址
   	*p = 10;  
   	return 0;
   }

5. 也可以用动态分配的内存空间来初始化一个引用变量。

   #include <iostream>  // c++ 包含头文件输入输出流
   #include <iomanip>
   using namespace std;
   
   int main() { 
   	float& reff = *new float;  // 用new开辟一个空间取一个别名reff
   	reff = 200;  // 给空间赋值
   	cout << reff; // 输出200
   	delete& reff; // 收回这个空间
   	return 0;
   }

这个空间只有别名，但程序可以引用到。

6. 指针与引用的区别

   • 指针式通过地址间接访问某个变量，而引用是通过别名直接访问某个变量。
   • 引用必须初始化，而一旦被初始化后不得再作为其他变量的别名。

   当&a的前面有类型符的时候(如 int &a)，它必然是对引用的声明，如果前面无类型符(如 cout << &a)，则是取变量的地址。

   非法声明:

   1. 企图建立数组的引用；int &a[9];
   2. 企图建立指向引用的指针； int &*p;
   3. 企图建立引用的引用； int &&px;

7. 对常量(用const声明)的引用

   #include <iostream>  // c++ 包含头文件输入输出流
   #include <iomanip>
   using namespace std;
   
   int main() { 
   	const int& r = 8; // 说明r为常量，不可以赋值
   	cout << "r=" << r << endl;
   	// r+=15; // r为常量不可用作赋值运算
   	cout << "r=" << r << endl;
   	return 0;
   }

   

8. 引用于函数

   引用的用途主要是用来做函数参数豁函数的返回值。引用函数坐函数的形参，实际上是在被调函数种对实参变量进行操作。

   #include <iostream>  // c++ 包含头文件输入输出流
   #include <iomanip>
   using namespace std;
   
   void change(int& x, int& y) {
   	int t; 
   	t = x;
   	x = y;
   	y = t;
   }
   
   int main() { 
   	int a = 3, b = 5;
   	change(a, b); // 实参为变量
   	cout << a << '\t' << b << endl;
   	return 0;
   }

   

9. 函数的返回值为引用类型

   可以把函数定义为引用类型，这时候函数的返回值即为某一变量的引用(别名)，因此它相当于返回了一个变量，所以可以对其返回值进行赋值操作，这一点类同于函数的返回值为指针类型。

   #include <iostream>  // c++ 包含头文件输入输出流
   #include <iomanip>
   using namespace std;
   
   int a = 4;
   int& f(int x) {
   	a = a + x;
   	return a;
   }
   
   int main() { 
   	int t = 5;
   	cout << f(t) << endl; // a = 9
   
   	f(t) = 20;  // a = 20; t = 5
   	cout << f(t) << endl;  // a = 25, t = 5
   
   	t = f(t); // a = 30, t = 30
   	cout << f(t) << endl; // 60
   	
   	return 0;
   }

   

   一个函数返回引用类型，必须返回某个类型的变量。getdata() = 8; 相当于 int &temp = 8; temp = 8;。

   由于函数调用返回的引用类型是在函数运行结束后产生的，所以函数不能返回自动变量和形参。返回的变量的引用，这个变量必须是全局变量或静态局部变量，即存储在静态区中的变量。

10. const类型变量

    当用const限制说明标识符时，表示所说明的数据类型为常量类型，可分为const型常量和const型指针。可用const限制定义标识符量。如：

    const int MaxLine = 1000;
    const float Pi = 3.1415926;

    用const定义的标识符常量，一定要对其初始化，在说明时进行初始化时对这种常量置值得唯一方法，不能用赋值运算符对这种常量进行赋值。如MaxLine = 35; // 错误使用。

    • const指针禁写指针 ：
      声明语句格式为： 数据类型 * const 指针变量名。 如 int r = 6; int *const pr = &r;则指针pr被禁写，即pr将始终指向一个地址，成为一个指针型常量，它将不能再作为左值而放在赋值号得左边。同样，禁写指针一定要定义的时候赋初值，虽然指针被禁写，但其间接引用没有被禁写既可以通过pr对r进行赋值。*pr=8。

    #include <iostream>  // c++ 包含头文件输入输出流
    #include <iomanip>
    using namespace std;
    
    int main() { 
    	int x = 900;
    	int* const px = &x;
    	cout << &x << endl;
    	cout << px << endl;
    	cout << *px << endl;
    	*px = 799;
    	cout <<* px << endl;
    	return 0;
    }

    

    • 禁写间接引用 ，声明格式如下：const 数据类型 * 指针变量名。
      所声明得指针指向同一禁写得实体，即间接引用不能被改写，如：const int *p;。所以程序中不能出现诸如 *p = 的语句，但指针p并未被禁写，因而可对指针p进行改写。

    #include <iostream>  // c++ 包含头文件输入输出流
    #include <iomanip>
    using namespace std;
    
    int main() { 
    	int a = 3, b = 5;
    	const int* pa = &b;  // 可以不赋初值
    	pa = &a; // 指针变量可以重新赋值
    	cout << *pa << endl; // 输出3
    
    	// *pa = 10; //非法，指针指向的内容不能赋值。
    	a = 100; // 变量可以重新赋值
    	cout << *pa << endl; // 输出100
    
    	return 0;
    }

    • 禁写指针又禁写间接引用 将上面两种情况结合起来，声明语句为：
      const 数据类型 * const 指针变量名; 如：const int *const px = &x; 说明：px是一个指针常量，它指向一禁写的实体，并且指针本身也被禁写。如px=，*px= 此类的语句都是非法的，在定义的时候必须赋初值。

---

知行合一，拒绝不动手的空想~