精华内容
下载资源
问答
  • c++基础语法
    千次阅读
    2021-09-27 08:27:59

    本专栏“C++快速入门”系列旨在帮助信息学竞赛初学者尽快能够了解C++语法规则并编写一些简单程序,因此会避免讲解太多枯燥理论,直接上机帮助同学们理解编程。
    在编程学习的开始前送给大家一句话:编程不是看会也不是听会的,而是练会的。检验编程学习的唯一标准就是能够成功设计编写程序,文中会包含大量经典实例,请同学们在阅读时同步练习。

    一、Dev-C++的安装与设置

    中学信息学竞赛所使用的编程软件大多为Dev-C++,可以进行代码的编写、调试、编译、运行,下载软件包后默认安装即可,安装完后可以进行一些简单的设置。

    1、语言设置:tools→environment→language→chinese
    设置软件界面语言为中文
    2、显示最多警告(便于调试代码):工具→编译选项→代码生成/优化→code warnings-show most warnings
    在这里插入图片描述

    二、编写第一个程序

    1、新建:
    文件-新建-源代码(Ctrl+N)
    2、程序代码框架:

    #include<bits/stdc++.h> //万能头文件,省力但会导致编译速度变慢,有利有弊 
    using namespace std;    //名字空间 
    int main(){             //主函数
        cout<<"HelloWorld!"<<endl;  //程序主体 
        return 0;           //主程序返回值 
    }
    

    3、保存C++文件:
    文件-保存(Ctrl+S)
    C++文件后缀名:cpp
    4、编译、运行
    编译的作用:将CPP文件编译为exe可执行文件
    快捷键:f11

    三、C++代码书写规则

    1、使用英文输入法输入字母、标点符号
    2、语句以分号";"结尾
    3、算数运算:+ - * / %(求余)。其中乘号不可省略,求余运算%
    4、程序代码基本按照“定义变量→输入数据→处理数据→输出数据”的顺序编写
    5、输入:cin>>项目1>>项目2>>…>>项目n; 输出:cout项目1<<项目2<<…<<项目n;
    6、C++中所支持的数据类型有:基本类型(整型int、浮点型/实型double、字符型char、逻辑型bool、指针类型、空类型)和构造类型(枚举型、数组、结构体和共用体类型)
    7、定义变量格式:数据类型 变量名;例如定义一个浮点型变量:double a; 常用变量名有i,j,a,b,c,d,e,r,l,s,m,n,w。
    8、变量赋值格式:变量名=值或者表达式,使用变量前必须先定义,可在定义变量时进行赋值,例如,定义两个值为0和1的整型变量a:int a=0,b=1;
    9、C++中算术运算是分数据类型的,整数与整数运算的结果是整数,如5/4的结果为1,整数与浮点数运算的结果是浮点数,如5.0/4的结果为1.25
    10、精确n位小数:cout<<fixed<<setprecision(n)<<变量或表达式;
    11、行注释语句:// ,块注释语句:/**/

    更多相关内容
  • 刚入门学习C++,跟随b站黑马程序员学习,自己记录的一些小笔记。后面会根据学习继续慢慢更新!
  • 说实话c++还是以前在学校的时候用过的,从毕业到现在一直用c嵌入式编程,现在重新搬出C++语法 ,如果理解上有错误的地方,还请路过的朋友多指正~~~ 构造函数用来构造一个对象,主要完成一些初始化工作,如果类...
  • c++基础语法

    2013-05-08 17:56:36
    很全的c++语法,入门级资料,简单易懂,快来看吧!!!
  • 语法:数据类型 变量名 = 初始值; 常量 作用:用于记录程序中不可更改的数[C++定义常量两种方式 1.#define宏常量:# define 常量名 常量值 通常在文件上方定义,表示一个常量 2.const修饰的变量:const 数据类型 ...

    封面来自互联网侵删
    视频地址:点击访问
    (我这里开发工具选用VSstudio)

    此笔记有三个系列:

    1. C++基础语法入门篇
    2. C++核心编程篇 点击查看
    3. C++提高编程篇

    C++初识

    变量

    作用:给一段指定的内存空间起名,方便操作这段内存
    语法:数据类型 变量名 = 初始值;

    常量

    作用:用于记录程序中不可更改的数[C++定义常量两种方式
    1.#define宏常量:# define 常量名 常量值
    通常在文件上方定义,表示一个常量
    2.const修饰的变量:const 数据类型 常量名 = 常量值
    通常在变是定义前加关键字const,修饰该变量为常量,不可修改

    关键字

    作用:关键字是C++中预先保留的单词(标识符)
    在定义变量或者常量时候,不要用关键字

    标识符命名规则

    作用:C++规定给标识符(变量、常量)
    命名时,有—套自己的规则
    ■标识符不能是关键字
    ■标识符只能由字母、数字、下划线组成
    ■第一个字符必须为字母或下划线
    标识符中字母区分大小写

    数据类型

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

    整型

    C++中能够表示整型的类型有以下几种方式,区别在于所占内存空间不同:

    sizeof关键字

    作用:利用sizeof关键字可以统计数据类型所占内存大小
    语法:sizeof(数据类型/变量)

    实型(浮点型float/double)

    作用:用于表示小数
    浮点型变量分为两种:
    1.单精度float
    2.双精度double
    两者的区别在于表示的有效数字范围不同:

    默认情况下输出一个小数,会显示出6位有效数字

    #include <iostream>
    using namespace std;
    
    int main() {
    	
    	 float f1 = 3.14f;//后边加float是因为小数一般默认为double形式
    	 double d1 = 3.14;
    	 cout << "f1 = " << f1 << endl;
    	 cout << "d1 = " << d1 << endl;
    
    	 //科学计数法
    	 float f2 = 3e2;//3 * 10^2
    	 float f3 = 3e-2;//3 * 0.1 ^ 2;
    	 cout << "f2 = " << f2 << endl;
    	 cout << "f3 = " << f3 << endl;
    
    	return 0;
    
    }
    

    结果:

    字符型(char)

    作用:字符型变量用于显示单个字符
    语法:char ch = ‘a’;
    注意
    1.在显示字符型变量时,用单引号将字符括起来,不要用双引号注意
    2.单引号内只能有一个字符,不可以是字符串

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

    转义字符

    作用:用于表示—些不能显示出来的ASCII字符
    常用的转义字符:\n \\ \t

    #include <iostream>
    using namespace std;
    
    int main() {
    	
    	 cout << "aa\thello world" << endl;
    	 cout << "aaaa\thello world" << endl;
    	 cout << "aaaaaa\thello world" << endl;
    	
    	return 0;
    
    }
    

    结果:

    字符串(string)

    作用:用于表示一串字符工两种风格

    • C风格字符串:char 变量名[ ] = “字符串值”
    • C++风格字符串:string 变量名 = "字符串值”(使用时要使用头文件#include < string>)

    布尔类型(bool)

    作用:布尔数据类型代表真或假的值
    bool类型只有两个值:

    • true —真(本质是1)
    • false —假(本质是0)
      bool类型占1个字节大小
      (bool类型只要不是0都代表真)(bool类型只要不是0都代表真)

    运算符

    算术运算符


    两个小数不可以做取模运算(只有整型变量可以进行取模运算)

    赋值运算符

    比较运算符

    逻辑运算符

    程序流程结构

    C/C++支持最基本的三种程序运行结构:顺序结构、选择结构、循环结构

    选择结构

    if语句

    作用:执行满足条件的语句if语句的三种形式

    • 单行格式if语句
    • 多行格式if语句
    • 多条件的if语句

    案例(三只小猪称体重)

    #include <iostream>
    using namespace std;
    /*有三只小猪ABC,请分别输入三只小猪的体重,并且判断哪只小猪最重*/
    int main() {
    	
    	int a, b, c = 0;
    	cout << "依次输入三只小猪的体重"<<endl;
    	cin >> a; cin >> b;cin >> c;
    	char t = 'a';//记录小猪的名字
    	cout << t;
    	int num = 0;//记录小猪体重
    	if (a < b) {
    		t = 'b';
    		num = b;
    	}if (t < c) {
    		t = 'c';
    	}
    	cout << "三只小猪中最重的是"<<t;
    	return 0;
    
    }
    

    三目运算符

    作用:通过三目运算符实现简单的判断
    语法:表达式1 ? 表达式2 :表达式3
    解释:
    如果表达式1的值为真,执行表达式2,并返回表达式2的结果;
    如果表达式1的值为假,执行表达式3,并返回表达式3的结果。

    switch语句

    • switch缺点,判断时候只能是整型或者字符型,不可以是一个区间
    • switch优点,结构清晰,执行效率高|Ⅰ
    • switch语句中表达式类型只能是整型或者字符型
    • case里如果没有break,那么程序会—直向下执行

    循环结构

    while循环语句

    案例(三只小猪称体重)

    #include <iostream>
    using namespace std;
    //time系统时间头文件
    #include <ctime>
    
    /*案例描述:系统随机生成一个1到100之间的数字,玩家进行猜测,如果猜错,
    提示玩家数字过大或过小,如果猜对恭喜玩家胜利,并且退出游戏。
    */
    
    int main() {
    
    	//添加随机种子,利用当前系统时间生成随机数,防止每次随机数都一样
    	srand((unsigned int)time(NULL));
    	int num = rand() % 100 + 1;
    
    	int val = 0;//玩家猜测的数字
    	while (true) {
    		cout << "请玩家输入你猜测的数字" << endl;
    		cin >> val;
    		if (num > val) {
    			cout << "猜测的数字偏小" << endl;
    		}
    		else if (num < val) {
    			cout << "猜测的数字偏大" << endl;
    		}
    		else {
    			cout << "猜对了" << endl;
    			break;
    		}
    	}
    	return 0;
    
    }
    

    结果:

    do…while循环语句

    案例(水仙花数)

    #include <iostream>
    using namespace std;
    
    
    /*案例描述:水仙花数是指一个3位数,它的每个位上的数字的3次幂之和等于它本身例如:1^3+5^3+ 3^3=153
    请利用do...while语句,求出所有3位数中的水仙花数
    */
    
    int main() {
    
    	int num = 100;
    	do {
    		int bai = num / 100;
    		int shi = num % 100 / 10;
    		int ge = num % 10;
    		int sum = bai * bai * bai + shi * shi * shi + ge * ge * ge;
    		if (sum == num) {
    			cout << num << endl;
    		}
    		num++;
    	} while (num < 1000);
    
    	return 0;
    
    }
    

    结果:

    for循环语句

    案例(敲桌子)

    #include <iostream>
    using namespace std;
    
    
    /*案例描述:从1开始数倒数字100,如果数字个位含有7,或者数字十位含有7,或者该数字是7的倍数
    我们打印敲桌子,其余数字直接打印输出。
    
    */
    
    int main() {
    
    	for (int i = 1; i <= 100; i++) {
    		if (i % 10 == 7 || i / 10 == 7 || i % 7 == 0) {
    			cout << "敲桌子"<<endl;
    		}
    		else {
    			cout << i << endl;
    		}
    	}
    
    	return 0;
    
    }
    

    结果:

    嵌套循环

    案例(乘法口诀表)

    #include <iostream>
    using namespace std;
    
    
    /*
    乘法口诀表
    */
    
    int main() {
    
    	for (int i = 1; i < 10; i++) {
    		for (int t = 1; t <= i; t++) {
    			cout << t << "×" << i << "=" << t * i<<"\t";
    			
    		}cout << endl;
    	}
    
    	return 0;
    
    }
    

    结果:

    跳转语句

    break语句

    作用:用于跳出选择结构或者循环结构break使用的时机

    • 出现在switch条件语句中,作用是终止case并跳出switch
    • 出现在循环语句中,作用是跳出当前的循环语句
    • 出现在嵌套循环中,跳出最近的内层循环语句

    continue语句

    goto语句

    作用:可以无条件跳转语句
    语法:goto 标记;
    解释:如果标记的名称存在,执行到goto语句时,会跳转到标记的位置
    不建议使用

    #include <iostream>
    using namespace std;
    
    int main() {
    
    	cout << "1.XXXXX." << endl;
    	cout << "2.XXXXX." << endl;
    	cout << "3.XXXXX." << endl;
    	goto FLAG;
    	cout << "4.XXXXX." << endl;
    	cout << "5.XXXXX." << endl;
    	FLAG:
    	cout << "6.XXXXX." << endl;
    	cout << "7.XXXXX." << endl;
    
    	return 0;
    
    }
    

    结果:

    数组

    所谓数组,就是一个集合,里面存放了相同类型的数据元素

    • 特点1∶数组中的每个数据元素都是相同的数据类型
    • 特点2:数组是由连续的内存空间组成的

    一维数组

    定义方式

    一维数组有三种定义方式:

    数组名

    —维数组名称的用途:
    1.可以统计整个数组在内存中的长度
    2.可以获取数组在内存中的首地址
    arr = 100;错误,数组名是常量,不可以赋值,但每次重新运行都会重新分配内存,所以运行同一个程序每次得到的数组的首地址不一定相同

    #include <iostream>
    using namespace std;
    
    int main() {
    
    	int arr[] = { 1,2,3,4 };
    	cout << "数组首地址:"<<arr << endl;
    	cout << "数组第一个元素地址:" << arr[0] << endl;
    	cout << sizeof(arr) << endl;
    
    	return 0;
    
    }
    

    两次运行结果:

    案例(五只小猪称体重)

    #include <iostream>
    using namespace std;
    
    /*
    在一个数组中记录了五只小猪的体重,
    如: int arr[5] = {300,350,200,400,250}; 找出并打印最重的小猪体重。
    */
    
    int main() {
    
    	int arr[5] = { 300,350,200,400,250 };
    	int temp = arr[0];//记录每两个比较的比较重的一方的体重
    	for (int i = 1; i < 5; i++) {
    		if (temp < arr[i]) {
    			temp = arr[i];
    		}
    	}
    	cout << "最重的小猪体重是:" << temp << endl;
    
    	return 0;
    
    }
    

    结果:

    案例()

    int length = sizeof(arr) / sizeof(arr[0]);//数组长度

    #include <iostream>
    using namespace std;
    
    /*
    案例描述:请声明一个5个元素的数组,并且将元素逆置.
    (如原数组元素为:1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);
    
    */
    
    int main() {
    
    	int arr[5] = { 1,3,2,5,4 };
    	int temp = 0;//辅助元素交换
    	int length = sizeof(arr)/sizeof(arr[0]);//数组长度
    	//cout << length << endl;
    	for (int i = 0; i <= length/2; i++) {
    		temp = arr[i];
    		int end = length - i;
    		arr[i] = arr[length-1 - i];
    		arr[length-1 - i] = temp;
    	}
    	cout << "逆置后数组为:";
    	for (int n = 0; n < length; n++) {
    		cout << arr[n] << " ";
    	}
    	
    	return 0;
    
    }
    

    结果:

    冒泡排序

    作用:最常用的排序算法,对数组内元素进行排序
    1.比较相邻的元素。如果第一个比第二个大,就交换他们两个。
    2.对每一对相邻元素做同样的工作,执行完毕后,找到第一个最大值。
    3.重复以上的步骤,每次比较次数-1,直到不需要比较


    #include <iostream>
    using namespace std;
    
    /*
    案例描述:请声明一个5个元素的数组,并且将元素逆置.
    (如原数组元素为:1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);
    
    */
    
    int main() {
    
    	int arr[ ] = {4,2,8,0,5,7,1,3,9};
    	int temp = 0;//辅助元素交换
    	int length = sizeof(arr)/sizeof(arr[0]);//数组长度
    	cout << "初始数组为:";
    	for (int n = 0; n < length; n++) {
    		cout << arr[n] << " ";
    	}cout << endl;
    
    	for (int i = 0; i < length-1 ; i++) {
    		for (int n = 0; n < length -i-1; n++) {
    			temp = arr[n];
    			if (arr[n] > arr[n+1]) {
    				arr[n] = arr[n + 1];
    				arr[n + 1] = temp;
    			}
    
    		}
    		
    	}
    	cout << "排序后数组为:";
    	for (int n = 0; n < length; n++) {
    		cout << arr[n] << " ";
    	}
    	
    	return 0;
    
    }
    

    结果:

    二维数组

    二维数组定义的四种方式:
    1.数据类型数组名[行数][列数];
    2.数据类型数组名[行数][列数]={ {数据1,数据2},{数据3,数据4 }};
    3.数据类型数组名[行数][列数]={数据1,数据2,数据3,数据4};
    4.数据类型数组名[ ][列数]={数据1,数据2,数据3,数据4};
    建议:以上4种定义方式,利用第二种更加直观,提高代码的可读性
    可以省去行数,但不可以省去列数

    函数

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

    值传递

    • 所谓值传递,就是函数调用时实参将数值传入给形参
    • 值传递时,如果形参发生改变,并不会影响实参

    常见样式

    常见的函数样式有4种
    1.无参无返
    2.有参无返
    3.无参有返
    4.有参有返

    函数声明

    • 作用:告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
    • 函数的声明可以多次,但是函数的定义只能有一次

    函数的分文件编写

    作用:让代码结构更加清晰函数分文件编写
    一般有4个步骤
    1.创建后缀名为.h的头文件
    2.创建后缀名为.cpp的源文件
    3.在头文件中写函数的声明
    4.在源文件中写函数的定义

    指针

    指针的作用:可以通过指针间接访问内存

    • 内存编号是从0开始记录的,一般用十六进制数字表示
    • 可以利用指针变量保存地址

    指针的定义和使用

    #include <iostream>
    using namespace std;
    
    /*
    */
    
    int main() {
    	//定义指针
    	int a = 10;
    	int* p = &a;
    	cout << "a的地址:" << &a << endl;
    	cout << "指针p为:" << p << endl;
    
    	//使用指针
    	//可以通过解引用的方式来找到指针指向的内存
    	//指针前加*代表解引用,找到指针指向的内存中的数据
    	cout << "a=" << a << endl;
    	cout << "*p=" << *p << endl;
    	return 0;
    }
    

    结果:

    指针所占内存空间

    #include <iostream>
    using namespace std;
    
    /*
    */
    
    int main() {
    	//定义指针
    	int a = 10;
    	int* p = &a;
    	
    	cout << "指针p所占内存:" << sizeof(p) << endl;//sizrof(int*)
    
    	
    	return 0;
    }
    

    结果:

    1. 在32位操作系统下,无论什么类型的指针都占4字节(X86)
    2. 在64位操作系统下,无论什么类型的指针都占8字节(X64)

    空指针和野指针

    空指针

    空指针:指针变量指向内存中编号为0的空间
    用途:初始化指针变量
    注意:空指针指向的内存是不可以访问的
    0~255之间的内存编号是系统占用的,我们没有权限访问

    野指针

    指针变量指向非法的内存空间

    const修饰指针

    const修饰指针有三种情况:

    1. const修饰指针——常量指针
      const int *p = 10;
      指针的指向可以改,但是指针指向的值不可以改
    2. const修饰常量——指针常量
      int * const p = 10;
      指针的指向不可以改,但指针指向的值可以改
    3. const即修饰指针,又修饰常量
      const int * const p = 10;
      指针的指向不可以改,指针指向的值不可以改

    指针和数组

    作用:利用指针访问数组中元素

    #include <iostream>
    using namespace std;
    
    /*
    */
    
    int main() {
    	int arr[] = { 1,2,3,4 };
    	int* p = arr;
    	for (int i = 0; i < 4; i++) {
    		cout << "  " << *p ;
    		p++;
    	}
    
    
    	return 0;
    }
    

    结果:

    如果不想修改实参,就用值传递,如果想修改实参,就用地址传递

    指针、数组、函数

    案例(函数实现冒泡)

    描述:封装一个函数,利用冒泡排序,实现对整型数组的升序排序
    例如数组: int arr[10]={ 4,3,6,9,1,2,10,8,7,5};

    #include <iostream>
    using namespace std;
    
    /*
    封装一个函数,利用冒泡排序,实现对整型数组的升序排序
    */
    void sort(int length, int* arr);
    int main() {
    	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
    	int length = sizeof(arr) / sizeof(int);
    	sort(length, arr);
    	for (int i = 0; i < 10; i++) {
    		cout << arr[i] << " ";
    	}
    	return 0;
    }
    void sort(int length,int *arr) {
    	for (int i = 0; i < length - 1; i++) {
    		for (int n = 0; n < length-i - 1; n++) {
    			if (arr[n] > arr[n + 1]) {
    				int temp = arr[n];
    				arr[n] = arr[n + 1];
    				arr[n + 1] = temp;
    			}
    		}
    	}
    }
    

    结果:

    结构体

    结构体属于用户自定义的数据类型,允许用户存储不同的数据类型

    结构体的定义和使用

    语法:struct 结构体名 {结构体成员列表};
    通过结构体创建变量的方式有三种:

    • struct 结构体名 变量名
    • struct结 构体名 变量名= {成员1值,成员2值…}
    • 定义结构体时顺便创建变量

    定义结构体时的关键字是struct,不可省略:
    创建结构体变量时,关键字struct可以省略

    结构体指针

    const在结构体的使用

    案例一

    学校正在做毕设项目,每名老师带领5个学生,总共有3名老师,需求如下
    设计学生和老师的结构体,其中在老师的结构体中,有老师姓名和一个存放5名学生的数组作为成员
    学生的成员有姓名、考试分数,创建数组存放3名老师,通过函数给每个老师及所带的学生赋值最终打印出老师数据以及老师所带的学生数据。

    #include <iostream>
    using namespace std;
    #include <string>
    struct Student {
    	string sName;
    	int Score;
    };
    struct Teacher {
    	string tName;
    	struct Student sArr[5];
    };
    
    //给老师赋值
    void write(int len, struct Teacher tArr[]) {
    	string seed = "ABCDE";
    	for (int i = 0; i < len; i++) {
    		tArr[i].tName = "teacher_";
    		tArr[i].tName += seed[i];
    		for (int j = 0; j < 5; j++) {
    			tArr[i].sArr[j].sName = "student_";
    			tArr[i].sArr[j].sName += seed[j];
    			tArr[i].sArr[j].Score = 60;
    		}
    	}
    }
    //打印
    void printshow(int len, struct Teacher tArr[])
    {
    	for (int i = 0; i < len; i++) {
    		cout << "老师名字:" << tArr[i].tName << endl;
    		for(int j = 0; j < len; j++) {
    			cout << "学生名字:" << tArr[i].sArr[j].sName 
    				<<"  考试分数:"<< tArr[i].sArr[j].Score << endl;
    		}
    	}
    }
    int main() {
    	struct Teacher tArr[3];
    	int len = sizeof(tArr) / sizeof(tArr[0]);
    	write(len, tArr);
    	printshow(len, tArr);
    	return 0;
    }
    

    结果:

    案例二

    设计一个英雄的结构体,包括成员姓名,年龄,性别;创建结构体数组,数组中存放5名英雄。通过冒泡排序的算法,将数组中的英雄按照年龄进行升序排序,最终打印排序后的结果。

    #include <iostream>
    using namespace std;
    #include <string>
    
    struct Yingxiong {
    	string name;
    	int age;
    	string sex;
    };
    void sort(int len,struct Yingxiong arr[]) {
    	for (int i = 0; i < len - 1;i++) {
    		for (int n = 0; n < len - i - 1; n++) {
    			if (arr[n].age > arr[n + 1].age) {
    				Yingxiong temp = arr[n];
    				arr[n] = arr[n + 1];
    				arr[n + 1] = temp;
    			}
    		}
    	}
    }
    void show(int len, struct Yingxiong arr[]) {
    	for (int i = 0; i < len; i++) {
    		cout << arr[i].name << "\t" << arr[i].age << "\t" << arr[i].sex<<endl;
    	}
    }
    int main() {
    	struct Yingxiong arr[5] =
    	{
    		{"刘备",23,"男"},
    		{"关羽",22,"男"},
    		{"张飞",20,"男"},
    		{"赵云",21,"男"},
    		{"貂蝉",19,"女"},
    	};
    	int len = sizeof(arr) / sizeof(arr[0]);
    	sort(len, arr);
    	show(len, arr);
    	return 0;
    }
    

    结果:


    这里交换时,是根据年龄判断大小然后互换的是整个结构体,如果只互换年龄就会导致人名和年龄以及性别不匹配的问题。

    通讯录管理系统

    (可以根据自己的喜欢增加系统功能)

    系统需求

    通讯录是一个可以记录亲人、好友信息的工具。
    本教程主要利用C++来实现一个通讯录管理系统系统中需要实现的功能如下:

    • 添加联系人:向通讯录中添加新人,信息包括(姓名、性别、年龄、联系电话、家庭住址)最多记录1000人
    • 显示联系人:显示通讯录中所有联系人信息
    • 删除联系人:按照姓名进行删除指定联系人
    • 查找联系人:按照姓名查看指定联系人信息
    • 修改联系人:按照姓名重新修改指定联系人
    • 清空联系人:清空通讯录中所有信息
    • 退出通讯录:退出当前使用的通讯录

    添加联系人

    添加联系人实现步骤:

    • 设计联系人结构体
    • 设计通讯录结构体
    • main函数中创建通讯录
    • 封装添加联系人函数
    • 测试添加联系人功能

    删除联系人

    根据姓名查找删除联系人
    功能描述:按照姓名进行删除指定联系人
    删除联系人实现步骤:

    • 封装枪测联系人是否存在
    • 封装删除联系人函数
    • 测试删除联系人功能

    封装检测联系人是否存在
    设计思路:
    删除联系人前,我们需要先判断用户输入的联系人是否存在,如果存在删除,不存在提示用户没有要删除的联系人。因此我们可以把检测联系人是否存在封装成一个函数中,如果存在,返回联系人在通讯录中的位置,不存在返回-1

    重点

    1. -
    2. 点击任意键进行清屏
      点击任意键进行清屏
    3. 删除联系人操作实质上:下一个数据覆盖前一个数据

    源代码

    #include <iostream>
    using namespace std;
    #include <string>
    
    #define MAX 1000
    //联系人结构体
    struct Person {
    	string m_Name;//姓名
    	string m_Sex;//性别
    	int m_age;//年龄
    	string m_Phone;//电话
    	string m_Addr;//地址
    };
    // 通讯录结构体
    struct Addressbooks {
    	struct Person personArray[MAX];
    	int m_Size;//通讯录中人数
    };
    //菜单
    void showMenu() {
    	cout << "■■■■■■■■■■■■■" << endl;
    	cout << "■■■1. 添加联系人 ■■■" << endl;
    	cout << "■■■2. 显示联系人 ■■■" << endl;
    	cout << "■■■3. 删除联系人 ■■■" << endl;
    	cout << "■■■4. 查找联系人 ■■■" << endl;
    	cout << "■■■5. 修改联系人 ■■■" << endl;
    	cout << "■■■6. 清空联系人 ■■■" << endl;
    	cout << "■■■0. 退出通讯录 ■■■" << endl;
    	cout << "■■■■■■■■■■■■■" << endl;
    }
    //添加联系人
    void addPersion(Addressbooks *abs) {
    	//通讯录是否已经满了
    	if (abs->m_Size == MAX) {
    		cout << "通讯录已满,无法添加!" << endl;
    		return;
    	}else {
    		string name;
    		cout << "请输入姓名:" << endl;
    		cin >> name;
    		abs->personArray[abs->m_Size].m_Name = name;
    
    		string sex;
    		cout << "请输入性别:" << endl;
    		cin >> sex;
    		abs->personArray[abs->m_Size].m_Sex = sex;
    
    		int age = 0;
    		cout << "请输入年龄:" << endl;
    		cin >> age;
    		abs->personArray[abs->m_Size].m_age = age;
    
    		string phone;
    		cout << "请输入电话:" << endl;
    		cin >> phone;
    		abs->personArray[abs->m_Size].m_Phone = phone;
    
    		string address;
    		cout << "请输入地址:" << endl;
    		cin >> address;
    		abs->personArray[abs->m_Size].m_Addr = address;
    		
    		//更新通讯录
    		abs->m_Size++;
    		
    		cout << "添加成功!" << endl;
    		//system("pause");
    		//system("cls");
    	}
    	system("pause");
    	system("cls");
    }
    void showPerson(Addressbooks* abs) {
    	if (abs->m_Size == 0) {
    		cout << "记录为空!" << endl;
    	}
    	else {
    		cout << "姓名\t性别\t年龄\t电话\t地址" << endl;
    		for(int i = 0;i < abs->m_Size;i++){//小心溢出
    			
    			cout << abs->personArray[i].m_Name
    				<<"\t" << abs->personArray[i].m_Sex 
    				<< "\t" << abs->personArray[i].m_age 
    				<< "\t" << abs->personArray[i].m_Phone 
    				<< "\t" << abs->personArray[i].m_Addr 
    				<<endl;
    		}
    		
    	}
    		system("pause");
    		system("cls");
    }
    //检测联系人是否存在,如果存在,返回联系人数组所在的具体位置,不存在返回-1
    int isExit(Addressbooks* abs, string name) {
    	for (int i = 0; i < abs->m_Size; i++) {
    		if (abs->personArray[i].m_Name == name) {
    			return i;
    		}
    		
    	}
    	return -1;
    }
    //删除联系人
    void deletePerson(Addressbooks* abs ) {
    	cout << "输入您想要删除的联系人:" << endl;
    	string name;
    	cin >> name;
    	//判断这个人是否存在
    	int ret = isExit(abs, name);
    	if (ret == -1) {
    		cout << "查无此人" << endl;
    	}
    	else {
    		for (int i = ret; i < abs->m_Size; i++) {
    			//数据前移
    			abs->personArray[i] = abs->personArray[i + 1];
    		}
    		abs->m_Size--;//更新人数
    		cout << "删除成功" << endl;
    	}
    	system("pause");
    	system("cls");
    }
    //查找联系人
    void searchPerson(Addressbooks* abs) {
    	cout << "请输入您需要查找的联系人:" << endl;
    	string name;
    	cin >> name;
    	int ret = isExit(abs, name);
    	if (ret == -1) {
    		cout << "查无此人" << endl;
    	}
    	else {
    		cout << "姓名\t性别\t年龄\t电话\t地址" << endl;
    		cout << abs->personArray[ret].m_Name
    			<< "\t" << abs->personArray[ret].m_Sex
    			<< "\t" << abs->personArray[ret].m_age
    			<< "\t" << abs->personArray[ret].m_Phone
    			<< "\t" << abs->personArray[ret].m_Addr
    			<< endl;
    	}
    	system("pause");
    	system("cls");
    }
    //修改联系人
    void alterPerson(Addressbooks* abs) {
    	cout << "请输入您需要修改的联系人:" << endl;
    	string name;
    	cin >> name;
    	int ret = isExit(abs, name);
    	if (ret == -1) {
    		cout << "查无此人" << endl;
    	}
    	else {
    		cout << "修改前的信息:" << endl;
    		cout << "姓名\t性别\t年龄\t电话\t地址" << endl;
    		cout << abs->personArray[ret].m_Name
    			<< "\t" << abs->personArray[ret].m_Sex
    			<< "\t" << abs->personArray[ret].m_age
    			<< "\t" << abs->personArray[ret].m_Phone
    			<< "\t" << abs->personArray[ret].m_Addr
    			<< endl;
    		cout << "选择您想要修改当前人的信息(姓名/性别/年龄/电话/地址):";
    		string num;
    		cin >> num;
    		if (num == "姓名") {
    			cout << "请输入新的" << num << "信息:";
    			string name1;
    			cin >> name1;
    			abs->personArray[ret].m_Name = name1;
    		}if (num == "性别") {
    			cout << "请输入新的" << num << "信息:";
    			string sex1;
    			cin >> sex1;
    			abs->personArray[ret].m_Sex = sex1;
    		}if (num == "年龄") {
    			cout << "请输入新的" << num << "信息:";
    			int age1;
    			cin >> age1;
    			abs->personArray[ret].m_age = age1;
    		}if (num == "电话") {
    			cout << "请输入新的" << num << "信息:";
    			string phone1;
    			cin >> phone1;
    			abs->personArray[ret].m_Phone = phone1;
    		}if (num == "地址") {
    			cout << "请输入新的" << num << "信息:";
    			string address1;
    			cin >> address1;
    			abs->personArray[ret].m_Addr = address1;
    		}
    		cout << "修改后的信息:" << endl;
    		cout << "姓名\t性别\t年龄\t电话\t地址" << endl;
    		cout << abs->personArray[ret].m_Name
    			<< "\t" << abs->personArray[ret].m_Sex
    			<< "\t" << abs->personArray[ret].m_age
    			<< "\t" << abs->personArray[ret].m_Phone
    			<< "\t" << abs->personArray[ret].m_Addr
    			<< endl;
    		cout << "修改成功!" << endl;
    	}
    	system("pause");
    	system("cls");
    }
    //清空联系人
    void cleanPerson(Addressbooks* abs) {
    	abs->m_Size = 0;
    	cout << "通讯录已清空!" << endl;
    	system("pause");
    	system("cls");
    }
    int main() {
    	//创建通讯录
    	Addressbooks abs;
    	abs.m_Size = 0;
    	
    	while (true) {
    		showMenu();
    		int select = 0;//记录用户的输入
    		cin >> select;
    		switch (select) {
    			case 1: //添加联系人
    				addPersion(&abs);//利用地址传递可以修饰实参
    				break;
    			case 2: //显示联系人
    				showPerson(&abs);
    				break;
    			case 3: //删除联系人
    				deletePerson(&abs);
    				break;
    			case 4: //查找联系人
    				searchPerson(&abs);
    				break;
    			case 5: //修改联系人
    				alterPerson(&abs);
    				break;
    			case 6: //清空联系人
    				cleanPerson(&abs);
    				break;
    			case 0:	//退出通讯录
    				cout << "欢迎下次使用" << endl;
    				exit(0);
    				break;
    			default:
    				cout << "请根据提示选择正确的操作" << endl;
    				break;
    		}
    	}
    	
    	
    	return 0;
    }
    

    结果:

    运行程序,当前通讯录中没有数据




    现在向通讯录中添加三个联系人:
    显示联系人:

    查找联系人:

    修改联系人:

    删除联系人并查看:


    清空联系人并显示:


    退出通讯录:

    展开全文
  • C++基础语法:链表

    千次阅读 2021-08-19 20:53:10
    因为在C++语言中,当我们生成一个数组的时候,就要声明数组的长度,如此计算机便会在内存上开辟一个连续的不间断的内存空间来存储数据,因为存在着这样的一种可能,也就是数组所使用的内存空间之后的内存空间已经被...

    链表是物理存储单元上非连续的,非顺序的存储结构,链表是由一个个结点,通过指针来联系起来的,其中每个结点包含数据和指针:

     

    或者我们采用另一张更加明显的图:

    因为在C++语言中,当我们生成一个数组的时候,就要声明数组的长度,如此计算机便会在内存上开辟一个连续的不间断的内存空间来存储数据,因为存在着这样的一种可能,也就是数组所使用的内存空间之后的内存空间已经被使用,所以C++中一旦数组的大小明确了,就不能够再改变了。而且因为数组是存储一系列的同一类型的变量的集合,所以构成数组的每一个元素占用的内存空间的大小是一样的。

    而如果我们使用链表,则可以达到如下所示的效果:

    构成链表的每一个结点都分配在非连续的位置,结点与结点之间通过指针连在了一起,如此可以随意的对链表进行扩张或者在某一个节点插入一个新的节点,只需要这个节点的内存地址被包含在上一个节点当中,并且该节点包含了指向下一个结点的内存地址。

    链表索然在修改上要强于数组,但是在查找上要弱于数组。因为链表中的结点在内存空间上的存储是非连续的,所以如果我们需要知道第n个节点的值,则需要访问第n-1个节点的才能够知道第n个节点的内存地址,进而的知道该内存地址所存储的数据的值。同理,我们也需要访问第n-2个节点,才能够知道第n-1个节点的内存地址;如此往复,如果我们需要知道第n个结点的值,我们还需要从第一个结点开始。间复杂度是O(n),比起数组的 O(1),差距不小。

    此外,使用数组有利于程序的局部性原理。CPU在读取到数组中的第一个元素的时候,这个元素地址附近的元素会被提前加载到缓存中,这么做能够提升程序的性能。但是因为链表中的结点的内存地址是随机分布的,所以无法利用到程序局部性原理来提前加在关联的数据从而提升程序的性能。

    为了在C++中表示链表,需要有一个表示链表中单个结点的数据类型。从结点的属性来看,这样的一个数据类型不但需要存储的数据结构,还要有一个指向另一个相同类型结点的指针。

    这里假设每个结点将存储一个类型为double的数据项,则可以声明以下类型来存放结点:

    struct ListNode{
        double value;
        ListNode *next;
    }

    在以上代码中,ListNode是要存储在链表中的结点的类型,结构成员value是结点的数据部分,而另一个结构成员next则被声明为ListNode的指针,它是指向下一个结点的后续指针。

    ListNode 结构有一个有趣的属性,它包含一个指向相同类型数据结构的指针,因此可以说是一个包含对自身引用的类型。像这样的类型称为自引用数据类型或自引用数据结构

    当我们声明了一个数据类型来表示结点之后,可以用这个数据类型来定义一个初始为空的链表,方法是定义一个用作链表头的指针并将其初始化为nullptr:

    ListNode *head = nullptr;

    现在可以创建一个链表,其中包含一个结点,将这个节点存储值为12.5:

    head = new ListNode; //分配新结点
    head->value = 12.5; //存储值
    head->next = nullptr; //表示链表的结尾

    因为ListNode的数据类型包含了指向于先一个结点的指针,所以在没有下一个结点的情况之下,要使其等于nullptr。

    如果我们创建一个新结点,在其中存储一个值为13.5的值,将其作为链表中的第二个结点,代码如下所示:

    ListNode *secondPtr = new ListNode;
    secondPtr->value = 13.5;
    secondPtr->next = nullptr; //第二个结点是链表的结尾
    head->next = secondPtr; //第一个结点指向第二个

    通过 head->next = secondPtr; 语句将链表头的后继指针改为指向第二个结点;指针 secondPtr->next 设置为 nullptr,可以使第二个结点成为链表的结尾。

    由此我们得到了这样的一个程序:

    // This program illustrates the creation || of linked lists.
    #include <iostream>
    using namespace std;
    struct ListNode
    {
        double value;
        ListNode *next;
    };
    int main()
    {
        ListNode *head = nullptr;
        
        // Create first node with 12.5
        head = new ListNode; // Allocate new node
        head->value = 12.5;    // Store the value
        head->next = nullptr; // Signify end of list
        
        // Create second node with 13.5
        ListNode *secondPtr = new ListNode;
        secondPtr->value = 13.5;
        secondPtr->next = nullptr; // Second node is end of list
        head->next = secondPtr; // First node points to second
        
        // Print the list
        cout << "First item is " << head->value << endl;
        cout << "Second item is " << head->next->value << endl;//重点
        return 0;
    }

    程序的输出结果为:

    First item is 12.5
    Second item is 13.5

    在c++的结构体中可以有构造函数,对于定义链表结点类型的结构来说,如果能给它提供一个或多个构造函数,那么将会带来很大的方便,因为这样将使得结点在创建时可初始化。

    如此,对ListNode结构进行另一个定义:

    struct ListNode
    {
        double value;
        ListNode *next;
        //构造函数
        ListNode(double valuel, ListNode *nextl = nullptr)
        {
            value = value1;
            next = next1;
        }
    }

    使用上述的声明,可以使用以下两种不同的方式创建一个结点:

    1. 通过仅指定其value部分,而后续指针则默认为nullptr
    2. 通过指定value部分和一个指向链表下一个结点的指针

    当需要创建一个结点放在链表的末尾时,第一种方式是很有用的;但是当创建新的结点讲被插入链表中间某个有后续节点的地方时,第二种方法是很有用的。

    我们可以这样写:

    ListNode *secondPtr = new ListNode(13.5);
    ListNode *head = new ListNode(12.5, secondPtr);

    第一行代码创建了第二个结点,传递了13.5的值,而因为没有传递指针值,所以这个节点是链表的末尾;第二行代码创建了第一个结点,传递了12.5的值和指针值secondPtr作为存储在这个结点中的内存地址数据。

    从链表头开始,涉及整个链表,并且在每个结点上执行一些处理操作的过程被称为遍历链表。

    例如,如果需要打印某个链表中每个结点的内容,则必须遍历该链表。假设某个链表的链表头指针是 numberList,要遍历该链表,则需要使用另一个指针 ptr 指向链表的开头:

    ListNode *ptr = numberList;

    然后就可以通过使用表达式 *ptr 或者使用结构指针操作符 -> 来处理由 ptr 指向的结点。例如,如果需要打印在结点上的值,则可以编写以下代码:

    cout << ptr->value;

    一旦在该结点的处理完成,即可将指针移动到下一个结点(如果有的话),其语句如下:

    ptr = ptr->next;

    以上语句使用指向结点后继的指针来替换了指向该结点的指针,实现了结点之间的移动。因此,要打印整个链表,可以使用如下代码:

    ListNode *ptr = numberList;
    while (ptr != nullptr)
    {
        cout << ptr->value << " "; //处理结点(显示结点内容)
        ptr = ptr->next; //移动到下一个结点
    }
    展开全文
  • C++基础语法:循环语句

    千次阅读 2021-08-18 04:54:56
    C++语言中,循环有两大类:while循环和for循环。while循环下面有一个do-while循环。 循环的逻辑如下图所示: 我们可以先来写一个while循环:要求对小于10的正整数进行求和。 我们可以用while循环来写出一段...

    在C++语言中,循环有两大类:while循环和for循环。while循环下面有一个do-while循环。

    循环的逻辑如下图所示:

    我们可以先来写一个while循环:要求对小于10的正整数进行求和。

    我们可以用while循环来写出一段如下所示的代码:

    #include <iostream>
    #include <cstdio>
    using namespace std;
    
    int main(){
        
        int count, num;
        count = 0;
        num = 0;
        while (num<10){
            count = count + num;
            num ++;
        }
        
        cout << count << endl;
        
        return 0;
    }

    运行的结果为:

    45

    或者问题也可以复杂一点:要求输入两个正整数,对两个正整数之间的数(包括两个正整数)进行求和:

    #include <iostream>
    #include <cstdio>
    using namespace std;
    
    int main(){
        
        int small,big,count;
        count = 0;
        cin >> small >> big;
        
        while (small <= big){
            count = count + small;
            small ++;
        }
        
        cout << count << endl;
        
        return 0;
    }

    while循环可能会一次都不会执行,当条件被测试且结果为假时,会跳过循环主体,直接执行紧接着 while 循环的下一条语句。如果循环被执行,那么while循环的条件需要被循环的主体进行改变,如此才会出现while循环被终止的情况,否则会进入无限死循环当中。

    while循环常见的一个问题是:输入一个正整数n,要求打印出来斐波那契数列的前N项。

    斐波那契数列的定义可以参考下图:

    代码如下所示:

    #include<iostream>
    using namespace std;
    typedef long long ll;
    int main(){
        int n;
        cin >> n;
        ll t1 = 0,t2 = 1,t3;
        while(n--){
            cout << t1 << ' ';
            t3 = t1 + t2;
            t1 = t2;
            t2 = t3;
        }
        return 0;
    }

    do-while循环不常用,do-while循环和while循环的区别在于:do-while循环会先对代码进行一次执行,然后再进行while语句的判断:

    #include <iostream>
    using namespace std;
     
    int main ()
    {
       // 局部变量声明
       int a = 10;
    
       // do 循环执行
       do
       {
           cout << "a 的值:" << a << endl;
           a = a + 1;
       }while( a < 20 );
     
       return 0;
    }

    运行的结果为:

    a 的值: 10
    a 的值: 11
    a 的值: 12
    a 的值: 13
    a 的值: 14
    a 的值: 15
    a 的值: 16
    a 的值: 17
    a 的值: 18
    a 的值: 19

    通常情况之下,我们只使用while循环。

    在C++语言中,最常用的还是for循环,for循环更加的适合编写和阅读:

    假设我们要求求0~100之间的3的倍数的和,我们可以写如下所示的一个代码:

    #include <iostream>
    #include <cstdio>
    using namespace std;
    
    int main(){
        
        int i = 0;
        int sum = 0;
        
        for (i; i <= 100; i++){
            if (i%3 == 0){
                sum += i;
            }
        }
        
        cout << sum << endl;
        
        return 0;
    }

    求得结果为:

    1683

    break关键词可以用来强制从循环中退出:

    我们可以写一段如下所示的代码:

    #include <iostream>
    using namespace std;
     
    int main ()
    {
       // 局部变量声明
       int a = 10;
    
       // do 循环执行
       do
       {
           cout << "a 的值:" << a << endl;
           a = a + 1;
           if( a > 15)
           {
              // 终止循环
              break;
           }
       }while( a < 20 );
     
       return 0;
    }

    运行的结果为:

    a 的值: 10
    a 的值: 11
    a 的值: 12
    a 的值: 13
    a 的值: 14
    a 的值: 15

    需要注意:如果使用的是嵌套循环(即一个循环内嵌套另一个循环),break 语句会停止执行最内层的循环,然后开始执行该块之后的下一行代码。

    与break对应的关键词为continue,continue会跳过需要执行的语句并且直接进入对下一个循环的判断:

    代码如下所示:

    #include <iostream>
    using namespace std;
     
    int main ()
    {
       // 局部变量声明
       int a = 10;
    
       // do 循环执行
       do
       {
           if( a == 15)
           {
              // 跳过迭代
              a = a + 1;
              continue;
           }
           cout << "a 的值:" << a << endl;
           a = a + 1;
       }while( a < 20 );
     
       return 0;
    }

    打印的结果为:

    a 的值: 10
    a 的值: 11
    a 的值: 12
    a 的值: 13
    a 的值: 14
    a 的值: 16
    a 的值: 17
    a 的值: 18
    a 的值: 19

    可以发现当a=15的时候,代码被跳过了没有执行。

    同样的,我们也刻意让for循环中嵌套for循环:查找0~100之间的质数:

    #include <iostream>
    using namespace std;
     
    int main ()
    {
        int i, j;
        for(i=2; i<100; i++) {
            for(j=2; j <= (i/j); j++) {
                if(!(i%j)) {
                    break; // 如果找到,则不是质数
                }
            }
            if(j > (i/j)) {
                cout << i << " 是质数\n";
            }
        }
        return 0;
    }

    运行的结果为:

    2 是质数
    3 是质数
    5 是质数
    7 是质数
    11 是质数
    13 是质数
    17 是质数
    19 是质数
    23 是质数
    29 是质数
    31 是质数
    37 是质数
    41 是质数
    43 是质数
    47 是质数
    53 是质数
    59 是质数
    61 是质数
    67 是质数
    71 是质数
    73 是质数
    79 是质数
    83 是质数
    89 是质数
    97 是质数

    循环的一个典型的问题是打印菱形:

    代码可以如下所示:

    #include<iostream>
    using namespace std;
    int main()
    {
        int n;
        cin>>n;
        for(int i=0;i<n;i++)
        {
            if(i<(n+1)/2)//判断是否在上面的三角形
            {
                for(int j=0;j<(n-1)/2-i;j++) cout<<" ";
                for(int j=0;j<i*2+1;j++) cout<<"*";
            }
            else
            {
                for(int j=0;j<i-(n-1)/2;j++) cout<<" ";
                for(int j=0;j<(n-i)*2-1;j++) cout<<"*";
            }
            cout<<endl;
        }
    }

    输入7,打印的结果为:

       *
      ***
     *****
    *******
     *****
      ***
       *
    展开全文
  • C/C++基础语法

    千次阅读 2019-12-07 19:48:48
    C程序的设计首要考虑的是如何通过一个过程,对输入(或环境条件)进行运算处理得到输出(或实现过程(事务)控制),而对于C++,首要考虑的是如何构造一个对象模型,让这个模型能够契合与之对应的问题域,这样就可以...
  • 从零到壹搞懂C++基础语法

    千次阅读 多人点赞 2022-02-07 09:39:14
    带大家10分钟快速过一遍C++基础语法,会从发展历程开始介绍,包括各个版本的特性,基本语法,数组、字符串、函数的使用。
  • C++基本语法

    千次阅读 2022-04-29 22:08:17
    文章目录数据类型定义结构体数组列表和循环二维点和三维点指针和引用文件类型头文件常见运算逻辑运算连续不等式浮点运算字符串操作常见报错及解决方法 数据类型定义 结构体 // 定义一个结构体 struct struct1{ ...
  • 配套视频: https://www.bilibili.com/video/BV1et411b73Z 为方便学习,在此发布C++基础入门部分配套讲义,原作者为黑马程序
  • C++ 基本语法

    2019-08-05 10:45:28
    一、C++ 基本语法 C++ 程序可以定义为对象的集合,这些对象通过调用彼此的方法进行交互。现在让我们简要地看一下什么是类、对象,方法、即时变量。 对象 - 对象具有状态和行为。例如:一只狗的状态 - 颜色、名称、...
  • C++基础语法:编译器

    千次阅读 2021-08-18 04:50:21
    推荐使用的是微软的Visual Studio: 当然也可是使用其他的编译器,或者使用云端的编译器。
  • c++核心语法

    2021-06-22 04:26:37
    从入门开始讲解到c++高级编程MFC界面编程...其次将C++核心操作语法和知识点,包括c++封装、继承、多态。然后讲C++的应用MFC界面编程,最后补充一点多线程知识。通过本课程学员可以从零基础跨越到非常熟练的C++程序员。
  • 从大学开始学习C语言,到后来学习C++、java、c#,编程语言逐渐从面向过程到面向对象,但面向对象的语言特性基本相似,基础语法差别并不是很大,在这里总结大家对于C++和JAVA两种语言的语法特性,记录下来作参考。...
  • C++考试语法基础

    2017-03-06 13:00:40
    C++考试,语法基础
  • C++ 语法详解

    2019-04-03 21:07:02
    C++语法详解》对C++语法进行了全面介绍和深入讲解,内容包括:C++整型、字符型、浮点型、声明、定义、typedef、运算符、表达式、左值、选择语句、循环语句、指针、数组、函数和标识符的作用域、类基础、类作用域及...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 172,565
精华内容 69,026
关键字:

c++基础语法

c++ 订阅