• C++ 基础入门

    1、变量

            作用：给一段指定的内存空间起名，方便操作这段内存。

    2、常量

            作用：用于记录程序中不可更改的数据

             C++中定义常量的两种方式：

    1. #define 宏常量： #define 常量名 常量值
    2. const修饰的变量：const数据类型  常量名 = 常量值   
    1. //1、宏常量
    2. #define day 7
    3.  
    4. int main() {
    5.  
    6. 	cout << "一周里总共有 " << day << " 天" << endl;
    7. 	//day = 8;  //报错，宏常量不可以修改
    8.  
    9. 	//2、const修饰变量
    10. 	const int month = 12;
    11. 	cout << "一年里总共有 " << month << " 个月份" << endl;
    12. 	//month = 24; //报错，常量是不可以修改的!（const修饰的变量也称为常量）
    13. 	
    14. 	system("pause");
    15.  
    16. 	return 0;
    17. }

    3、数据类型

            C++规定在创建一个变量或者常量时，必须要指定出相应的数据类型，否则无法给变量分配内存。

    3.1 整型

            C++能够表示整形的数据类型有以下几种方式，区别在于所占内存空间不同。

    数据类型占用空间取值范围
    short2字节(-2^15 ~ 2^15-1)
    int4字节(-2^31 ~ 2^31-1)
    longWindows为4字节，Linux为4字节(32位)，8字节(64位)(-2^31 ~ 2^31-1)
    long long8字节(-2^63 ~ 2^63-1)

    3.2 浮点型

            作用：用于表示小数。

            浮点型变量分为两种：

    1. 单精度：float
    2. 双精度：double

            单精度和双精度区别在于表示的有效数字范围不同 ：

    数据类型占用空间取值范围
    float4字节7位有效数据
    double8字节15～16位有效数字

    3.3  字符型

            作用：字符型变量用于显示单个字符

            语法：char ch = 'a';

    • C和C++中字符型变量只占用1个字节
    • 字符型变量并不是把字符本身放在内存总存储，而是将对应的ASCII编码放入到存储单元

    注意1：在显示字符型变量时，用单引号将字符括起来，不要用双引号

    注意2：单引号内只能有一个字符，不可以是字符串

    3.4 sizeof关键字

            作用：利用sizeof关键字可以统计数据类型所占内存空间大小。

            语法：sizeof( 数据类型 | 变量 )

    1. int main()
    2. {
    3.     // 整形
    4.     short num1 = 10;
    5.     int num2 = 10;
    6.     long num3 = 10;
    7.     long long num4 = 10;
    8.  
    9.     cout << "short所占内存空间大小" << sizeof(short) << endl;
    10.     cout << "num1所占内存空间大小" << sizeof(num1) << endl;
    11.  
    12.     cout << "int所占内存空间大小" << sizeof(int) << endl;
    13.     cout << "num2所占内存空间大小" << sizeof(num2) << endl;
    14.  
    15.     cout << "long所占内存空间大小" << sizeof(long) << endl;
    16.     cout << "num3所占内存空间大小" << sizeof(num3) << endl;
    17.  
    18.     cout << "long long所占内存空间大小" << sizeof(long long) << endl;
    19.     cout << "num4所占内存空间大小" << sizeof(num4) << endl;
    20.  
    21.     // 实数
    22.     float f1 = 3.14f;
    23.     double d1 = 3.14;
    24.  
    25.     cout << "float  sizeof = " << sizeof(f1) << endl;
    26.     cout << "double sizeof = " << sizeof(d1) << endl;
    27.  
    28.     // 字符型
    29.     char ch = 'a';
    30.     cout << ch << endl;
    31.     cout << "char sizeof ="<<sizeof(char) << endl;
    32. }

    3.5 字符串型

            作用：用于表示一串字符；

            两种风格的字符串表示形式：

                    1. C风格字符串：char 变量名[] = "字符串值"

    1. int main()
    2. {
    3. 	char str1[] = "wangy";
    4. 	cout << str1 << endl;
    5.  
    6. 	system("pause");
    7. 	return 0;
    8. }

                    2. C++风格字符串：string 变量名 = "字符串值"

    1. #include 
    2. using namespace std;
    3. int main()
    4. {
    5.     string str1 = "wangy";
    6. 	cout << str1 << endl;
    7.  
    8. 	system("pause");
    9. 	return 0;
    10. }

     4、数组

            所谓数组，就是一个集合，里面存放了相同类型的数据元素。数组具有如下两个特点：

    特点1：数组中的每个数据元素都是相同的数据类型

    特点2：数组是由连续的内存位置组成的（因此数组可以下标访问）

     4.1 一维数组

     数组定义：

            数组定义时，必须给定数据类型及长度！

    1. 数据类型  数组名[数组长度]； 
      1. 	//定义方式1
      2. 	//数据类型 数组名[元素个数];
      3. 	int score[10];
      4. 	//利用下标赋值
      5. 	score[0] = 100;
      6. 	score[1] = 99;
      7. 	score[2] = 85;
    2. 数据类型  数组名[数据长度]  =  {值1, 值2……}； 
      1. 	//第二种定义方式
      2. 	//数据类型 数组名[元素个数] =  {值1，值2 ，值3 ...};
      3. 	//如果{}内不足10个数据，剩余数据用0补全
      4. 	int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
      5. 	//一个一个输出太麻烦，因此可以利用循环进行输出
      6. 	for (int i = 0; i < 10; i++)
      7. 	{
      8. 		cout << score2[i] << endl;
      9. 	}
    3. 数据类型  数组名[ ] =  {值1, 值2……}； 
      1. 	//定义方式3
      2. 	//数据类型 数组名[] =  {值1，值2 ，值3 ...};
      3. 	int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
      4.  
      5. 	for (int i = 0; i < 10; i++)
      6. 	{
      7. 		cout << score3[i] << endl;
      8. 	}

    4.2 一维数组中的数组名

    一维数组名称的用途：

    1. 可以统计整个数组在内存中的长度
    2. 可以获取数组在内存中的首地址
    1. int main() {
    2.  
    3. 	//数组名用途
    4. 	//1、可以获取整个数组占用内存空间大小
    5. 	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    6.  
    7. 	cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
    8. 	cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
    9. 	cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;
    10.  
    11. 	//2、可以通过数组名获取到数组首地址
    12. 	cout << "数组首地址为： " << (int)arr << endl;
    13. 	cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl;
    14. 	cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;
    15.  
    16. 	//arr = 100; 错误，数组名是常量，因此不可以赋值
    17.  
    18. 	system("pause");
    19.  
    20. 	return 0;
    21. }
    1. int main()
    2. {
    3. 	int a[] = { 10,20,30 };
    4.  
    5. 	int len = sizeof(a) / sizeof(a[0]);
    6. 	cout<
    7. 	for (int i = 0; i < len; i++) {
    8. 		cout << a[i] << endl;
    9. 	}
    10.  
    11. 	cout << a << endl;
    12. 	for (int i = 0; i < len; i++) {
    13. 		cout << &a[i] << endl;
    14. 	}
    15. 	system("pause");
    16. 	return 0;
    17. }

     4.3 二维数组

    二维数组定义的四种方式：

    1. 数据类型 数组名[ 行数 ][ 列数 ];
    2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
    3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
    4. 数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};

    建议：以上4种定义方式，利用第二种更加直观，提高代码的可读性

    1. int main() {
    2. 	//方式1  
    3. 	//数组类型 数组名 [行数][列数]
    4. 	int arr[2][3];
    5. 	arr[0][0] = 1;
    6. 	arr[0][1] = 2;
    7. 	arr[0][2] = 3;
    8. 	arr[1][0] = 4;
    9. 	arr[1][1] = 5;
    10. 	arr[1][2] = 6;
    11. 	for (int i = 0; i < 2; i++)
    12. 	{
    13. 		for (int j = 0; j < 3; j++)
    14. 		{
    15. 			cout << arr[i][j] << " ";
    16. 		}
    17. 		cout << endl;
    18. 	}
    19.  
    20. 	//方式2 
    21. 	//数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
    22. 	int arr2[2][3] =
    23. 	{
    24. 		{1,2,3},
    25. 		{4,5,6}
    26. 	};
    27.  
    28. 	//方式3
    29. 	//数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4  };
    30. 	int arr3[2][3] = { 1,2,3,4,5,6 }; 
    31.  
    32. 	//方式4 
    33. 	//数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4  };
    34. 	int arr4[][3] = { 1,2,3,4,5,6 };
    35. 	
    36. 	system("pause");
    37. 	return 0;
    38. }

    4.4 二维数组数组名

    • 查看二维数组所占内存空间
    • 获取二维数组首地址
    1. int main() {
    2. 	//二维数组数组名
    3. 	int arr[2][3] =
    4. 	{
    5. 		{1,2,3},
    6. 		{4,5,6}
    7. 	};
    8.  
    9. 	cout << "二维数组大小： " << sizeof(arr) << endl;
    10. 	cout << "二维数组一行大小： " << sizeof(arr[0]) << endl;
    11. 	cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl;
    12.  
    13. 	cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl;
    14. 	cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
    15.  
    16. 	//地址
    17. 	cout << "二维数组首地址：" << arr << endl;
    18. 	cout << "二维数组第一行地址：" << arr[0] << endl;
    19. 	cout << "二维数组第二行地址：" << arr[1] << endl;
    20.  
    21. 	cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
    22. 	cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;
    23.  
    24. 	system("pause");
    25.  
    26. 	return 0;
    27. }

    5、函数

            作用：将一段经常使用的代码封装起来，减少重复代码

            一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

    1. //函数定义
    2. int add(int num1, int num2)
    3. {
    4. 	int sum = num1 + num2;
    5. 	return sum;
    6. }
    1. //函数定义
    2. int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参
    3. {
    4. 	int sum = num1 + num2;
    5. 	return sum;
    6. }
    7.  
    8. int main() {
    9.  
    10. 	int a = 10;
    11. 	int b = 10;
    12. 	//调用add函数
    13. 	int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
    14. 	cout << "sum = " << sum << endl;
    15.  
    16. 	a = 100;
    17. 	b = 100;
    18.  
    19. 	sum = add(a, b);
    20. 	cout << "sum = " << sum << endl;
    21.  
    22. 	system("pause");
    23.  
    24. 	return 0;
    25. }

    函数定义里小括号内称为形参，函数调用时传入的参数称为实参

    5.1 值传递

    • 所谓值传递，就是函数调用时实参将数值传入给形参
    • 值传递时，如果形参发生，并不会影响实参
    1. void swap(int num1, int num2)
    2. {
    3. 	cout << "交换前：" << endl;
    4. 	cout << "num1 = " << num1 << endl;
    5. 	cout << "num2 = " << num2 << endl;
    6.  
    7. 	int temp = num1;
    8. 	num1 = num2;
    9. 	num2 = temp;
    10.  
    11. 	cout << "交换后：" << endl;
    12. 	cout << "num1 = " << num1 << endl;
    13. 	cout << "num2 = " << num2 << endl;
    14.  
    15. 	//return ; 当函数声明时候，不需要返回值，可以不写return
    16. }
    17.  
    18. int main() {
    19.  
    20. 	int a = 10;
    21. 	int b = 20;
    22.  
    23. 	swap(a, b);
    24.  
    25. 	cout << "mian中的 a = " << a << endl;
    26. 	cout << "mian中的 b = " << b << endl;
    27.  
    28. 	system("pause");
    29.  
    30. 	return 0;
    31. }

    5.2 函数的声明

    作用： 告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

    • 函数的声明可以多次，但是函数的定义只能有一次

    示例：

    1. //声明可以多次，定义只能一次
    2. //声明
    3. int max(int a, int b);
    4. int max(int a, int b);
    5. //定义
    6. int max(int a, int b)
    7. {
    8. 	return a > b ? a : b;
    9. }
    10.  
    11. int main() {
    12.  
    13. 	int a = 100;
    14. 	int b = 200;
    15.  
    16. 	cout << max(a, b) << endl;
    17.  
    18. 	system("pause");
    19.  
    20. 	return 0;
    21. }

     5.3 函数的分文件编写

            作用：让代码结构更加清晰

    函数分文件编写一般有4个步骤：

    1. 创建后缀名为.h的头文件
    2. 创建后缀名为.cpp的源文件
    3. 在头文件中写函数的声明
    4. 在源文件中写函数的定义

    示例：

    1. //swap.h文件
    2. #include
    3. using namespace std;
    4.  
    5. //实现两个数字交换的函数声明
    6. void swap(int a, int b);
    1. //swap.cpp文件
    2. #include "swap.h"
    3.  
    4. void swap(int a, int b)
    5. {
    6. 	int temp = a;
    7. 	a = b;
    8. 	b = temp;
    9.  
    10. 	cout << "a = " << a << endl;
    11. 	cout << "b = " << b << endl;
    12. }
    1. //main函数文件
    2. #include "swap.h"
    3. int main() {
    4.  
    5. 	int a = 100;
    6. 	int b = 200;
    7. 	swap(a, b);
    8.  
    9. 	system("pause");
    10.  
    11. 	return 0;
    12. }

    5.4 函数默认参数

            在C++中，函数的形参列表中的形参是可以有默认值的。

            语法： 返回值类型 函数名 （参数= 默认值）{}

    1. int func(int a, int b = 10, int c = 10) {
    2. 	return a + b + c;
    3. }
    4.  
    5. //1. 如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
    6. //2. 如果函数声明有默认值，函数实现的时候就不能有默认参数（函数声明和实现只能有一个有默认实现）
    7. int func2(int a = 10, int b = 10);
    8. int func2(int a, int b) {
    9. 	return a + b;
    10. }
    11.  
    12. int main() {
    13.  
    14. 	cout << "ret = " << func(20, 20) << endl;
    15. 	cout << "ret = " << func(100) << endl;
    16.     cout << "ret = " << func2() << endl;
    17.  
    18. 	system("pause");
    19.  
    20. 	return 0;
    21. }

     5.5 函数重载

            作用：函数名可以相同，提高复用性

    函数重载满足条件：

    • 同一个作用域下
    • 函数名称相同
    • 函数参数类型不同 或者 个数不同 或者 顺序不同

    注意: 函数的返回值不可以作为函数重载的条件

     

    1. //函数重载需要函数都在同一个作用域下
    2. void func()
    3. {
    4. 	cout << "func 的调用！" << endl;
    5. }
    6. void func(int a)
    7. {
    8. 	cout << "func (int a) 的调用！" << endl;
    9. }
    10. void func(double a)
    11. {
    12. 	cout << "func (double a)的调用！" << endl;
    13. }
    14. void func(int a ,double b)
    15. {
    16. 	cout << "func (int a ,double b) 的调用！" << endl;
    17. }
    18. void func(double a ,int b)
    19. {
    20. 	cout << "func (double a ,int b)的调用！" << endl;
    21. }
    22.  
    23. //函数返回值不可以作为函数重载条件
    24. //int func(double a, int b)
    25. //{
    26. //	cout << "func (double a ,int b)的调用！" << endl;
    27. //}
    28.  
    29.  
    30. int main() {
    31.  
    32. 	func();
    33. 	func(10);
    34. 	func(3.14);
    35. 	func(10,3.14);
    36. 	func(3.14 , 10);
    37. 	
    38. 	system("pause");
    39. 	return 0;
    40. }

    5.6 函数重载注意事项 

    • 引用作为重载条件（只要符合重载条件，就允许）
    • 函数重载碰到函数默认参数（会出现二义性，因此函数重载时最好不要使用默认参数）
    1. //函数重载注意事项
    2. //1、引用作为重载条件（只要符合重载条件，就允许）
    3.  
    4. void func(int &a)
    5. {
    6. 	cout << "func (int &a) 调用 " << endl;
    7. }
    8.  
    9. void func(const int &a) // 合法的代码，const int 和 int符合参数不同
    10. {
    11. 	cout << "func (const int &a) 调用 " << endl;
    12. }
    13.  
    14.  
    15. //2、函数重载碰到函数默认参数（会出现二义性，因此函数重载时最好不要使用默认参数）
    16.  
    17. void func2(int a, int b = 10)
    18. {
    19. 	cout << "func2(int a, int b = 10) 调用" << endl;
    20. }
    21.  
    22. void func2(int a)
    23. {
    24. 	cout << "func2(int a) 调用" << endl;
    25. }
    26.  
    27. int main() {
    28. 	
    29. 	int a = 10;
    30. 	func(a); //调用无const
    31. 	func(10);//调用有const
    32.  
    33. 	//func2(10); //碰到默认参数产生歧义，需要避免
    34.  
    35. 	system("pause");
    36. 	return 0;
    37. }

     

  • 相关阅读:
    在springboot项目中显示Services面板的方法
    政安晨：【Keras机器学习示例演绎】（十四）—— 用于弱光图像增强的零 DCE
    【kafka】Timed out waiting for a node assignment
    20220918
    BL200Pro分布式IO模块如何配置WEB端
    Selenium —— 网页frame与多窗口处理！
    2023-10-10 LeetCode每日一题（奖励最顶尖的 K 名学生）
    #哈希表 电话号码查询系统(线性和链式)#
    WPF 启动项目 Grid、StackPanel 布局
    【C++】C&C++内存管理
  • 原文地址：https://blog.csdn.net/sssxlxwbwz/article/details/128051028