C++基础

已于 2023-09-08 10:15:28 修改
阅读量546 收藏 5
点赞数 1
分类专栏： c++ 文章标签： c++ 开发语言
于 2023-08-30 18:44:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NITIQ/article/details/132588545
版权

C++基础入门

1、创建项目

这里使用的是Visual Studio

image-20220820100106343

输入好自己的项目名称，然后选择位置后即可

image-20220820100156763

新建源文件，在这个位置右键

image-20220820100404737

选择C++文件，取好名字添加即可

image-20220820100438072

2、HelloWorld

那么我们就可以开始写第一个程序了，

#include <iostream>
using namespace std;

int main()
{ 
	cout << "hello C++" << endl;
	system("pause");
	return 0;
}

点击本地windows调试器，就输出了

image-20220820102510151

image-20220820102529084

3、注释

作用：在代码中加入一些说明和解释，方便自己或其他人阅读

在运行时，编译器会忽略这些注释的内容

两种格式

​ 1、单行注释 //

​ 通常放在一行代码的上方，或者一条语句的末尾，对该行代码说明

​ 2、多行注释 /* 这是多条注释*/

​ 通常放在一段代码的上方，对该段代码做整体说明

image-20220820202014004

4、变量

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

注意这个变量顾名思义，就是可以改变的数值

语法：数据类型 变量名 = 初始值；

image-20220820202508051

如上图所示，每块内存都有它自己的编号（0x0000），我们可以用编号来使用它，但是不便于管理，这时候我们将它取一个便于记住的名字（a），那么a就是变量名

#include<iostream>
using namespace std;

int main() {
	
	//变量创建的语法：数据类型 变量名 = 变量初始值

	int a = 10;
	cout << "a = " << a << endl;

	system("pause");

	return 0;
}

image-20220820203028412

5、常量

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

注意：这里的值不可以改变

  1. #define 宏常量： #define 常量名 常量值
    1. 通常在文件上方定义，表示一个常量
  2. const修饰常量：const 数据类型 常量名 = 常量值
    1. 通常在变量定义前加关键字const，修饰该变量为常量
#include<iostream>

using namespace std;

/*
常量的定义方式
1、#define 宏常量
2、const修饰的常量
*/

//1、#define 宏常量
#define Day  7


int main() {

	//Day = 14 这是不可以修改的 Day为常量，一旦修改就会报错
	cout << "一周一共有：" << Day << "天" << endl;

	//2、const 修饰常量
	const int month = 30;
	// month = 24 这里也是不可以修改的
	cout << "一月一共有：" << month << "天" << endl;

	system("pause");
	return 0;
}

image-20220820213403207

6、关键字

作用：关键字是C++中预先保留的单词

注意：在定义变量或者常量时不要使用

image-20220820213824626

7、命名规则

  • 标识符不能是关键字
  • 标识符只能由字母、数字、下划线组成
  • 第一个字符必须为字母或下划线
  • 标识符中字母区分大小写

给变量取名的时候做到见名知意

8、数据类型

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

8.1、整型

作用：整型变量表示整数的数据

以下在C++中有几种类型方式表示整型，区别在于内存空间不同

数据类型占用空间取值范围
short（短整型）2字节（-215~215-1）
int（整型）4字节（-231~231-1）
long（长整型）windos为4字节，linux为4字节(32位)，8字节（64位）（-231~s31-1）
long long（长长整型）8字节（-263~263-1）

值不可以超过这个取值范围不然会出错，c++会自动变成负数的第一位，依次类推

image-20220825142618548

image-20220825142634062

#include<iostream>
using namespace std;

int main() {

	//1、短整型(-32768~32767) 
	short num1 = 10;

	//2、整型
	int num2 = 10;

	//3、长整型
	long num3 = 10;

	//4、长长整型
	long long num4 = 10;

	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;
	cout << "num3 = " << num3 << endl;
	cout << "num4 = " << num4 << endl;

	system("pause");
	return 0;
}

8.2、sizeof关键字

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

语法：sizeof（数据类型/变量

#include<iostream>
using namespace std;

int main() {

	//利用sizeof求出数据类型占用的内存大小	
	short num1 = 10;
	cout << "short占用的内存空间为：" << sizeof(num1) << endl;
	int num2 = 10;
	cout << "int占用的内存空间为：" << sizeof(num2) << endl;
	long num3 = 10;
	cout << "long占用的内存空间为：" << sizeof(num3) << endl;
	long long num4 = 10;
	cout << "long long占用的内存空间为：" << sizeof(num4) << endl;
	system("pause");
	return 0;
}

image-20220825144141294

8.3、实型（浮点型）

作用：用于表示小数

浮点型变量分为两种：

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

两者的区别在于表示有效数字的范围不同

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

有效数字：例如3.14 这里的有效数字就为3位

c++中不管是单精度还是双精度默认只显示6位数字


#include<iostream>
using namespace std;

int main() {

	//1、单精度 float
	//这里加f的意思是让C++当成单精度处理，不然会自动转成双精度再转换成单精度
	float f1 = 3.142131f;
	cout << "f1=" << f1 << endl;
	cout << "float的内存空间" << sizeof(f1) << endl;

	//2、双精度
	double f2 = 3.1322312;
	cout << "f2=" << f2 << endl;
	cout << "double的内存空间" << sizeof(f2) << endl;

	//科学计数法
	float f3 = 3e2; //3*10 ^ 2
	cout << "f2=" << f3 << endl;
	float f4 = 3e-2; //3*0.1 ^ 2
	cout << "f4=" << f4 << endl;

	system("pause");
	return 0;
}

image-20220825145403641

8.4、字符型

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

语法：char ch = ‘a’;

注意：

  1. 再显示字符型变量时，要用单引号括起来，不要用双引号
  2. 单引号内只能有一个字符，不可以是字符串

c和c++中字符型变量值占用1个字节

字符型变量并不帅把字符串本身放到内存中存储，而是将对应的ASCII编码放入到存储单元


#include<iostream>
using namespace std;

int main() {
	char a = 'a';

	cout << "char所占内存空间" << sizeof(a) << endl;

	//字符型变量的常见错误
	//char c = "b"; //创建字符型变量时候，要用单引号
	//char c = 'asdsad'; //创建字符型变量时候，单引号只能有一个

	//4、字符型变量对应的ASCII编码
	// a = 97
	// A = 65
	char ch1 = 'a';
	cout << "a的ASCII编码" << (int)ch1 << endl;
	char ch2 = 'A';
	cout << "A的ASCII编码" << (int)ch2 << endl;

	system("pause");
	return 0;
}

image-20220825152431709

8.5、转义字符

作用：用于表示一些不能显示出来的ASCII字符

这里我只列举一些常用的

转义字符含义ASCII码值
\n换行010
\表示一个反斜杠字符"\"092
\t水平制表（跳到下个TAB位置）009

#include<iostream>
using namespace std;

int main7() {

	//1、单精度 float
	//这里加f的意思是让C++当成单精度处理，不然会自动转成双精度再转换成单精度
	float f1 = 3.142131f;
	cout << "f1=" << f1 << endl;
	cout << "float的内存空间" << sizeof(f1) << endl;

	//2、双精度
	double f2 = 3.1322312;
	cout << "f2=" << f2 << endl;
	cout << "double的内存空间" << sizeof(f2) << endl;

	//科学计数法
	float f3 = 3e2; //3*10 ^ 2
	cout << "f2=" << f3 << endl;
	float f4 = 3e-2; //3*0.1 ^ 2
	cout << "f4=" << f4 << endl;

	system("pause");
	return 0;
}

image-20220825153330656

8.6、字符串型

作用：用于表示一串字符

语法：string 变量名 = “字符串值”


#include<iostream>

using namespace std;

int main() {

	string str = "hello world";
	cout << str << endl;

	system("pause");
	return 0;
}

image-20220825153914924

如果报错的话，可以加一个头文件#include<string>

8.7、布尔类型

作用：布尔数据类型代表真或者假的值

bool类型只有俩个值

  1. true 表示 真 可以用 1 来表示
  2. flase 表示 假 可以用 0 来表示

bool类型占1个字节大小



#include<iostream>
using namespace std;

int main() {
	bool flag = true;
	cout << flag << endl;

    bool flag1 = false;
	cout << flag1 << endl;

	cout <<"bool占的内存空间:" << sizeof(flag1) << endl;

	system("pause");
	return 0;
}

image-20220825154338146

8.8 、数据的输入

作用：用于从键盘获取数据

关键字： cin

语法： cin>>变量

9、数组

​ 定义方式

  1. 数据类型 数组名 [数组长度];
    #定义
    int arr[5];
    #存数组
    arr[0] = 10;
    #输出
    cout<<arr[0]<<endl;
  1. 数据类型 数组名[数组长度] = {值1，值2,…}
	#定义
	#初始化没有定义值为0
	int arr2[5] = { 10,20,30,40,50 };
	cout << arr2[1] << endl;
  1. 数据类型 数组名[] = {值1，值2,…}
	int arr3[] = { 30,20,10 };

9.1、一维数组

  1. 可以统计整个数组在内存中的长度
int arr[4] = { 1,2,3,4 };
cout << sizeof(arr) << endl;
//16
  1. 可以获取数组在内存中的首地址
	cout << (int)arr << endl;	
//& 元素的首地址
	cout << (int)&arr << endl;

冒泡排序

	int arr[9] = { 4,2,8,0,5,7,1,3,9 };
	cout << "排序前：" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << "";
	}

	for (int i = 0; i < 9 - 1; i++)
	{
		for (int j = 0; j < 9-i-1; j++)
		{
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}

	cout << "排序后：" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << "";
	}

9.2、二维数组

	//1.数据类型 数组名[行数][列数]
	int arr[2][3];
	//赋值
	 arr[0][0] = 1;

	// 2.数据类型 数组名[行数][列数] = {{数据1，数据2},{数据3,数据4}}
	 int arr2[2][3] = {
		 {1,2,3},
		 {4,5,6}
	 };

	 // 3.数据类型 数组名[行数][列数] = {数据1，数据2，数据3，数据4};
	 int arr3[2][3] = { 1,2,3,4,5,6 };

	 // 4. 数据类型 数组名[ ][列数] = {数据1，数据2，数据3，数据4};
	//这里可以自动推断行数，但不能省列数
	 int arr4[][3] = { 1,2,3,4,5,6 };

可利用循环来做打印或赋值

外层循环打印行，内层循环打印列

	//行
	for (int i = 0; i < 2; i++)
	{
    //列
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << " ";
		}
        	cout << endl;
	}
9.2.1、二维数组名称

用途

  • 查看二维数组所占用的内存空间
	int arr[2][3] = {
		{1,2,3},
		{4,5,6}
	};
	cout << "所占用的内存空间:" << sizeof(arr) << endl;
	cout << "第一行所占用的内存空间:" << sizeof(arr[0]) << endl;
	cout << "第一个元素所占用的内存空间:" << sizeof(arr[0][0]) << endl;

//通过占用内存大小可以反向推断行列数
	cout << "二维数组行数为：:" << sizeof(arr)/sizeof(arr[0]) << endl;
	cout << "二维数组列数为：:" << sizeof(arr[0])/sizeof(arr[0][0]) << endl;
  • 获取二维数组首地址
	cout << "二维数组地址" << (int)arr << endl;

//第一行和第二行相差12字节
	cout << "二维数组第一行地址" << (int)arr[0] << endl;
	cout << "二维数组第二行地址" << (int)arr[1] << endl;

//第一个和第二个元素相差4字节
    cout << "二维数组第一个元素地址" << (int)&arr[0][0] << endl;
    cout << "二维数组第二个元素地址" << (int)&arr[0][1] << endl;

10、函数

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

10.1、函数的定义

  1. 函数值类型
  2. 函数名
  3. 参数表列
  4. 函数体语句
  5. return表达式

语法：

返回值类型 函数名（参数列表）
{
    函数体语句
    return表达式
}
//eg 加法
int add(int num1, int num2) {
	int sum = num1 + num2;
	return sum;
};

10.2、函数的调用

int main() {
	int a = 1;
	int b = 2;
	cout << add(a, b) << endl;
    
	system("pause");
	return 0;
}

10.3、 值传递

void 无类型，不需要返回值 不影响实参

//不影响实参
void swap(int num1, int num2) {
	int temp = num1;
	num1 = num2;
	num2 = temp;
    
	cout << "交换后" << endl;
	cout << "num1" << num1 << endl;
	cout << "num2" << num2 << endl;	
}

10.4、函数的常见样式

常见的函数样式4种

  1. 无参无返
void test01() {
	cout << "1213" << endl;
}
int main() {
	//无参无返
	test01();
	system("pause");
	return 0;
}
  1. 有参无返
void test02(int a ) {
	cout << "有参无返" << a << endl;
}
int main() {
	//有参无返
	test02(1);
	system("pause");
	return 0;
}
  1. 无参有返
int test03() {
	cout << "123" << endl;
	return 100;
}
int main() {
	//无参有反
	test03();
	system("pause");
	return 0;
}
  1. 有参有返
//有参有返
int test04(int a) {
	return a + 1;
}
int main() {
	cout<<test04(3);
	system("pause");
	return 0;
}

10.5、函数的声明

提前告诉编译器函数存在，避免报错，可以把函数放在main的后面。

  • 声明和定义的区别
    • 声明没有具体代码
    • 声明可以写多次，定义只能一次
//声明
int max(int a, int b);
int main() {
	int a = 1;
	int b = 2;

	cout<<max(a, b);
	system("pause");
	return 0;
}
//定义
int max(int a, int b) {
	return a > b ? a : b;
}

10.6、函数的分文件编写

使代码可读性更高，不堆积在一个文件中

创建步骤

  1. 创建.h后缀的头文件

img

  1. 创建.cpp后缀名的源文件

image-20230824222028435

  1. 在头文件中写函数的声明

image-20230824223026304

  1. 在源文件中写函数的定义

image-20230824223241909

image-20230824223257575

11、指针

作用：利用指针来访问内存（指针就是一个地址）

& 与 * 互为逆运算。& ，其作用是取变量的地址；* ，其作用是取地址对应的内存

  1. 定义

数据类型 * 指针变量名

	int a = 10;
	//指针定义的语法：数据类型 * 指针变量名;
	int * p;
	//让指针记录变量a的地址
	p = &a;
	//输出
	cout << "a的地址:" << &a << endl;
	cout << "指针P为:" << p << endl;
  1. 使用

利用解引用的方式来找到指针指向的内存

指针前加*代表解引用，找到指针指向内存中的数据

	//使用指针
	*p = 1000;
	//此时a的值为1000
	cout << "a=" << a << endl;
	cout << "*p=" << *p << endl;

11.1、指针占用的内存

指针所占用的空间跟操作系统有关，32位和64位操作系统

  1. 64位操作系统

image-20230825085321749

	int a = 10;
	int* p = &a;
	cout << "64位操作系统下占用的内存空间int:" << sizeof(int *) << endl;
	cout << "64位操作系统下占用的内存空间float:" << sizeof(float *) << endl;
	cout << "64位操作系统下占用的内存空间double:" << sizeof(double *) << endl;
	cout << "64位操作系统下占用的内存空间char:" << sizeof(char *) << endl;

image-20230825085355768

  1. 32位操作系统

image-20230825085425322

image-20230825085544873

11.2、空指针和野指针

空指针和野指针均不是我们所申请的空间，所以都不要访问

  1. 空指针：指针变量指向内存中编号为0的空间（0~255为系统占用不可访问）

用途：初始化指针变量

注意：空指针指向的内存不可访问

//初始化
int *p = null;
//空指针访问（会报错）
*p = 100;

image-20230825091553929

  1. 野指针：指向一个非法内存空间（随意指向一个内存地址），不是自己申请的。
	//指针变量p指向0x111的空间
	int * p = (int *)0x111;

	cout << *p<< endl;

image-20230825092201333

11.3、const修饰指针

  1. coust修饰指针—常量指针
  2. coust修饰常量 — 指针常量
  3. coust修饰指针和常量
  • 常量指针(只能修改指针指向的地址，不能修改值)
	int a = 10;
	int b = 20;
	const int * p = & a;

	//指向可修改，值不可被修改
		p = &b;
		*p = 20;//错误

image-20230825093736095

  • 指针常量（只能修改值，不能修改指向地址）
	int a = 10;
	int b = 20;
	int * const p = &a;

	//指向不可被修改，值可被修改
	*p = 20;
	p = &b;//错误

image-20230825093939005

  • coust修饰指针和常量（俩个均不可被修改）
	int a = 10;
	int b = 20;
	const int* const p = &a;

	//均不可被更改
	*p = 20;
	p = &b;

image-20230825094103055

11.4、指针数组

利用指针访问数组中的元素

	int arr[5] = { 1,2,3,4,5 };
	//利用指针指向数组首地址
	int * p = arr;
	for (int i = 0; i < 5; i++)
	{
		cout << *p << endl;
		cout << &*p << endl;
		//使地址每次向后移
		p++;
	}

image-20230825095929136

11.5、指针和函数

地址传递：当我们函数传入的是地址时，可以改变实参的数据

void swap(int* p1, int* p2) {
	int temp = *p1;//将值赋给temp
	*p1 = *p2;//将值赋给p1
	*p2 = temp;
}
int main() {
	int a = 10;
	int b = 20;
	cout << "a:" << a << endl;
	cout << "b:" << b << endl;

	swap(a, b);

	cout << "改变后a:" << a << endl;
	cout << "改变后b:" << b << endl;
	system("pause");
	return 0;
}

值传递和地址传递区别：值传递不改变值，地址传递改变参数的值

12.结构体

允许用户自定义的数据类型，允许用户存储不同的数据类型

  1. 语法

    //自定义数据类型，一些类型的集合组成的一个类型
//语法：struct 类型名称{}

    struct Student
{
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};

  2. 赋值

    1. 通过声明一个名字给它的属性赋值
    int main() {
	//直接声明赋值
	struct Student s1;
	s1.name = "张三";
	s1.age = 11;
	s1.score = 100;

	cout << "name:" << s1.name << "age:" << s1.age << "score:" << s1.score;
	system("pause");
	return 0;
}
    1. 直接赋值
    struct Student s2
	{
		"李四",
		17,
		200
	};
	cout << "name:" << s2.name << "age:" << s2.age << "score:" << s2.score << endl;;
    1. 创建结构体时创建结构体变量（不推荐）
    struct Student
{
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
}s3;

image-20230825111523381

struct 在c++中创建变量时可以可以省略，定义结构体不可被省略


	 Student s2
	{
		"李四",
		17,
		200
	};

12.1、结构体数组

将自定义的结构体放入到数组中方便维护

语法：数据类型 数组名 = { {…},{…},… }

struct Student
{
	string name;
	int age;
	int score;

};

int main() {
	Student stdArray[3] = {
		{"张三",11,122},
		{"李四",12,111},
		{"王五",13,322}

	};

	//修改元素
	stdArray[2].age = 100;
	cout << stdArray[2].age << endl;
	//输出
	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << stdArray[i].name << endl;
	}

	system("pause");
	return 0;
}

image-20230825112846281

12.2、结构体指针

通过指针访问结构体中的成员

  • 利用操作符·->可以通过指针访问结构体属性
struct Student
{
	string name;
	int age;
	int score;

};
int main() {
	Student s1 = { "张三",11,200 };
	Student * p = &s1;
	cout << p->name << p->age << p->score;
	system("pause");
	return 0;
}

12.3 、结构体嵌套结构体

结构体中的成员可以是另一个结构体

struct Student
{
	string name;
	int age;
	int score;

};
struct Teacher
{
	string name;
	int age;
	Student stu;
};

int main() {
	Teacher t;
	t.age = 1;
    //访问结构体中的结构体
	t.stu.age = 1;
	return 0;
}

12.4、结构体做函数参数

将函数体作为参数向函数中传递

传递的俩种方式

  • 值传递
  • 地址传递

想修改主函数中的数据地址传递，反之值传递

  1. 值传递 函数里面形参会发生变化，实参不会改变
//定义结构体
struct Student
{
	string name;
	int age;
	int score;

};
//输出
void printStudent(Student stu) {
	stu.age = 100;
	cout <<"修改后age：" << stu.age<<endl;
}
int main() {
	Student s1 = {
		"zy",
		11,
		12
	};
	cout << "修改前age：" << s1.age << endl;
	printStudent(s1);
	cout << "执行完age：" << s1.age << endl;
	t.stu.age = 1;
	return 0;
}

image-20230825215443660

  1. 地址传递:可通过地址修改实参
//定义结构体
struct Student
{
	string name;
	int age;
	int score;

};
//输出
void printStudent2(Student * p) {
	p->age = 200;
	cout << "修改后age：" << p->age << endl;
}
int main() {
	Student s1 = {
		"zy",
		11,
		12
	};
	cout << "修改前age：" << s1.age << endl;
	//printStudent(s1);
	printStudent2(&s1);
	cout << "执行完age：" << s1.age << endl;
	t.stu.age = 1;
	return 0;
}

image-20230825220520828

12.5、结构体中const使用场景

用const来防止误操作

void printStudent(const Student * p) {
	//不可被修改
    //p->age = 100;
	cout <<"修改后age：" <<p->age<<endl;
}
周粥粥ya
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++基础知识大全
weixin_49199646的博客
10-31 1万+
秋招基本尘埃落定了，打算总结一下C++学习路线的相关知识，今天是第一篇：C++基础知识总结。 面向对象的三大特性： 1、封装：把客观事物抽象为类，包含自己的属性和方法。 2、继承：使用现有类的所有功能，在无需重新编写原有类的情况下对类的功能进行拓展。被继承的类成为父类或基类，继承的类成为子类或派生类。 3、多态：一种形式，多种状态，分为静态多态和动态多态。静态多态指编译时多态，如函数重载、模板；动态多态指运行时多态，特指virtual虚函数机制形成的多态。 类的访问权限：private、protected
C++基础入门.pdf
04-10
C++基础入门 C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 ...
C++基础总结
weixin_40620310的博客
03-30 1万+
C++基础总结 一、基本的代码含义 1、程序的第一行#include <iostream>是预处理器指令，告诉 C++ 编译器在实际编译之前要包含iostream 文件； 2、using namespace std表示我们可以使用标准库中对象和变量的名称； 3、int main()是主函数，程序从这里开始执行； 4、/*...*/将会被编译器忽略，这里放置程序的注释内容。它们被称为程序的注释； 5、return 0;终止 main() 函数，并返回值 0； 二、定义常量的两种方式 1、const
C++基础入门
a577715979的博客
01-02 5026
C++入门
C++基础代码大全
QL857的博客
04-12 2万+
C++基础语言大全
C++基础知识点总结
深度学习 || 神经网络
02-07 1万+
自学c++过程中遇到的一些需要记忆的知识点,参考小甲鱼C++教程。
Qt学习之C++基础
RongLin02的博客
10-03 1万+
C++面向对象 类
C++基础知识
weixin_42397686的博客
06-12 2580
C++基础知识 一.C++与C语言的关系 C语言是C++的子集。C++是从C基础上发展而来的，C++程序能运行的环境也能运行C语言程序。 C面向对象；C++既支持面向对象，又支持面向过程。 二.数据类型 1. C语言中的数据类型 2. C++中新增的数据类型 示例： 三.C++随用随定义 示例： 四.输入/输出方式 1.C语言 scanf()函数与printf()函数 示例： 输入：scanf("%d %d",&x,&y); 输出：printf("%d %d\n",x,y);
C++基础语法：链表
baiyechangjiu的博客
08-19 7574
链表是物理存储单元上非连续的，非顺序的存储结构，链表是由一个个结点，通过指针来联系起来的，其中每个结点包含数据和指针： 或者我们采用另一张更加明显的图： 因为在C++语言中，当我们生成一个数组的时候，就要声明数组的长度，如此计算机便会在内存上开辟一个连续的不间断的内存空间来存储数据，因为存在着这样的一种可能，也就是数组所使用的内存空间之后的内存空间已经被使用，所以C++中一旦数组的大小明确了，就不能够再改变了。而且因为数组是存储一系列的同一类型的变量的集合，所以构成数组的每一个元素占用的内.
C++入门基础（万字详解！！！）
忘忧.
08-15 3万+
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
C++（c++基础入门，看这一篇就够了）
热门推荐
Xiaoming9106的博客
08-19 4万+
c plus plus 简称c++
C++基础入门.md
11-21
C++基础入门.md、C++基础入门.md、C++基础入门.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
c++基础教程
04-18
编写c++下的基础应用，是学习者的好例子，有助于概念的清晰
微机作业-c++基础从0到1
10-29
微机作业——c++基础从0到1 微机作业——c++基础从0到1 微机作业——c++基础从0到1 微机作业——c++基础从0到1 微机作业——c++基础从0到1 微机作业——c++基础从0到1 微机作业——c++基础从0到1 微机作业——c++...
C++基础入门.md.pdf
04-19
黑马程序员匠心之作
c++实现二叉搜索树（上）
最新发布
henjdx的博客
06-12 993
二叉搜索树1.树节点增加key属性，用来比较谁大谁小，key不可以重复2.对于任意一个节点，它的key比左子树的key都大，同时也比右子树的key都小善解人意的小吉猜很多小可爱们看到这些概念都很难一下子就理解了，接下来小吉画一张图，方便大家理解（比起上面👆的概念，小吉认为下面的图比较重要）注：标的数值都是键值最后，小吉来考考你们🧐，看看你们是否是真的了解了二叉搜索树，上图👆键值6的右子树的取值范围（>6&&
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 997
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 143
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 676
LeetCode 算法：轮转数组c++
devc++基础代码
09-13
以下是一个简单的 DevC++ 基础代码示例： ```c #include int main() { printf("Hello, World!\n"); return 0; } ``` 上述代码会在控制台输出 "Hello, World!"。你可以使用 DevC++ 编译器运行它，也可以将代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

周粥粥ya

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值