c++程序设计学习-1【基础语法部分】

良辰美景好时光

已于 2023-02-09 18:03:10 修改

阅读量363

点赞数

分类专栏： C++ 文章标签： c++ 学习开发语言

于 2023-01-22 21:03:48 首次发布

本文链接：https://blog.csdn.net/qq_45740503/article/details/128741310

版权

C++ 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

c++程序设计学习

基础语法部分

基础语法部分

01.第一个项目

#include <iostream>

int main()
{
    std::cout << "Hello World!\n";
}

02.验证空间大小

#include<iostream>


int main()
{
	//sizeof获取一个数据类型或者一个变量的空间占用大小
	std::cout << "short: " << sizeof(short) << std::endl;
	std::cout << "int: " << sizeof(int) << std::endl;
	std::cout << "long: " << sizeof(long) << std::endl;
	std::cout << "long long: " << sizeof(long long) << std::endl;
 	//sizeof获取一个数据类型或者一个变量的空间占用大小
	std::cout << "float: " << sizeof(float) << std::endl;
	std::cout << "double: " << sizeof(double) << std::endl;
	std::cout << "char: " << sizeof(char) << std::endl;
	std::cout << "bool: " << sizeof(bool) << std::endl;

	return 0;
}

short: 2
int: 4
long: 4
long long: 8
float: 4
double: 8
char: 1
bool: 1

03.数据类型

#include<iostream>
/*
* 变量和常量的定义
*/
int main()
{
	//布尔数据类型
	bool number = true;
	//变量的定义
	//语法1：数据类型 标识符
	//      注意事项：局部变量在使用之前，必须要赋值。
	int num;
	num = 10;
	std::cout << num << std::endl;

	//语法2：数据类型 标识符 = 初始值
	int num1 = 20;
	std::cout << num1 << std::endl;

	//语法3：数据类型 标识符1，标识符2，标识符3，...
	//      同时定义多个相同数据类型的变量，并且可以随时进行初始化的赋值操作
	int chineseScore = 100, mathScore, englishScore = 90;
	mathScore = 98;
	std::cout << "chineseScore = " << chineseScore << ",mathScore = " << mathScore << ",englishScore = " << englishScore << std::endl;


	//常量的定义，需要用到关键字const
	const float PI = 3.14;


	return 0;
}

10
20
chineseScore = 100,mathScore = 98,englishScore = 90

04.各种数据类型的变量定义

#include<iostream>
#include<iomanip>
/*
* 各种数据类型的变量的定义
*/
int main()
{
	//整型
	short num1 = 32767;
	int num2 = 10;
	long num3 = 10;
	long long num4 = 10;

	std::cout << "num1 = " << num1 << " , num2 = " << num2 << " , num3 = " << num3 << " , num4 = " << num4 << std::endl;
	//浮点型
	//注意事项：浮点型的字面量，默认的类型推导是double类型，如果给float类型的变量进行赋值的时候，会进行一次类型转换的操作。
	//			如果出于效率的考虑，如果要给float类型的变量进行赋值，最好在浮点型的字面量的最后，添加一个f。
	float f1 = 3.14f;
	double f2 = 3.14;

	std::cout << "f1 = " << f1 << std::endl;
	std::cout << "f2 = " << f2 << std::endl;

	float f11 = 30000.12345678901234567890f;
	double f21 = 30000.12345678901234567890;

	std::cout << std::setprecision(20) << "f11 = " << f11 << std::endl;
	std::cout << "f21 = " << f21 << std::endl;

	//布尔型
	//布尔型存在一个隐式的转换的，以0作为false，以非0作为true。
	bool b1 = true;
	bool b2 = false;
	std::cout << "b1 = " << b1 << ",b2 = " << b2 << std::endl;

	//字符型
	
	//字符串型


	return 0;
}

num1 = 32767 , num2 = 10 , num3 = 10 , num4 = 10
f1 = 3.14
f2 = 3.14
f11 = 30000.123046875
f21 = 30000.123456789013289
b1 = 1,b2 = 0

05.字符数据类型和字符串类型

#include <iostream>

int main()
{
	// 细说字符数据类型
	// 已知所有的数据在计算机中进行存储和运算的时候，都是以0、1的形式进行的
	// 因此每一个字符一定有一个数字与之对应
	// 此时就需要有一个“表格”，来记录每一个字符与数字之间的对应关系
	// 这样的“表格”，称为“字符集”，常见的字符集：ASCII、GB2312、GBK、Unicode、UTF-8

	// 单引号中，一般只写一个字符
	// 0110 0001 0110 0001 0110 0001 0110 0001
	char b = 'aaaa';
	char c = 'a';

	std::cout << c << std::endl;

	// 字符串类型
	// 由若干个字符组成的一个有序的字符序列
	std::string str = "Hello World";

	return 0;
}

06.转义字符

#include<iostream>

int main()
{
	// 转义字符：\
	// 作用1：配合某些特殊字符使用，使其变成普通字符
	// 作用2：配合某些特定的普通字符使用，代表某种特殊含义
	//       \t 制表符
	//       \n 换行符
	//       \r 回车符

	char c1='\'';
	std::string str1 = "Hello \" World";

	std::cout << c1 << std::endl;
	std::cout << str1 << std::endl;

	std::string str2 = "hello \n world";
	std::cout << str2 << std::endl;

	std::cout << '\\' << std::endl;

	return 0;
}

'
Hello " World
hello
 world
\

07.数据类型转换

#include<iostream>

int main()
{
	// char < short < int ~ long < long long < float < double

	// 自动类型转换
	//     由取值范围小的数据类型，向取值范围大的数据类型转换。
	//     转换的过程不需要额外的操作，直接赋值就可以了。
	//     不存在精度丢失的问题。

	int num1 = 100;
	long long num2 = num1;

	std::cout << "num2 = " << num2 << std::endl;

	char c1 = 'a';
	int num3 = c1;
	std::cout << "num3 = " << num3 << std::endl;

	float f1 = num1;
	std::cout << "f1 = " << f1 << std::endl;

	// 强制类型转换
	//     由取值范围大的数据类型，向数值范围小的数据类型转换
	int num4 = (int)num2;
	std::cout << "num4 = " << num4 << std::endl;

	// 0000 0000 0000 0000 0000 0000 1100 1000
	// 1100 1000 => 1011 1000 => -(32+16+8) = -56
	int num5 = 200;
	char c2 = (char)num5;
	std::cout << "c2 + 1 = " << c2 + 1 << std::endl;

	// 注意事项：
    // 1. 在进行运算的时候，计算结果的数据类型会向上对齐。
	int nn1 = 100;
	long long nn2 = 200;
	auto res = nn1 + nn2;
	std::cout <<"sizeof(nn1 + nn2) = " << sizeof(nn1 + nn2) << std::endl;

	// 2. 在进行运算的时候，char、short类型结果会自动的转换成int类型。
	short s1 = 100, s2 = 100;
	auto res2 = s1 + s2;

	// 3. 浮点型向整型转换的时候，会舍去小数点后面的所有部分，只保留整数部分。
	float f2 = 3.94f;
	int i1 = (int)f2;
	std::cout << "i1 = " << i1 << std::endl;

	return 0;
}

num2 = 100
num3 = 97
f1 = 100
num4 = 100
c2 + 1 = -55
sizeof(nn1 + nn2) = 8
i1 = 3

08.控制台输入

#include<iostream>

int main()
{
	// 控制台输入：读取控制台上输入的内容，并且给某一变量进行赋值
	// cin
	
	// 整型的数字
	int n1 = 0;
	std::cout << "请输入一个整型的数字：";
	std::cin >> n1;
	std::cout << "n1 = " << n1 << std::endl;

	// 浮点型的数字
	float n2 = 0;
	std::cout << "请输入一个浮点型的数字：";
	std::cin >> n2;
	std::cout << "n2 = " << n2 << std::endl;

	// 布尔型的变量
	bool n3 = false;
	std::cout << "请输入一个布尔值：";
	std::cin >> n3;
	std::cout << "n3 = " << n3 << std::endl;

	// 字符型的变量
	char n4 = 0;
	std::cout << "请输入一个字符：";
	std::cin >> n4;
	std::cout << "n4 = " << n4 << std::endl;

	// 字符串类型的变量
	std::string n5 = "";
	std::cout << "请输入一个字符串：";
	std::cin >> n5;
	std::cout << "n5 = " << n5 << std::endl;

	return 0;
}

请输入一个整型的数字：5
n1 = 5
请输入一个浮点型的数字：3.14
n2 = 3.14
请输入一个布尔值：1
n3 = 1
请输入一个字符：a
n4 = a
请输入一个字符串：abc
n5 = abc

int main()
{
	// 1.缓冲区的问题
	//   其实我们在控制台上输入的内容，是被暂时存到了一个“缓冲区”，cin从缓冲区取数据给变量进行赋值。
	//   std::cin.ignore();//默认忽略一位
	//   std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//忽略整个缓冲区
	int num1 = 0, num2 = 0, num3 = 0;
	std::cin >> num1;
	std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//忽略整个缓冲区
	std::cin >> num2;
	std::cin >> num3;
	std::cout << "num1 = " << num1 << ",num2 = " << num2 << ",num3 = " << num3 << std::endl;
	
	return 0;
}

3.14 234
123
456
num1 = 3,num2 = 123,num3 = 456

int main()
{
	// 1.缓冲区的问题
	//   其实我们在控制台上输入的内容，是被暂时存到了一个“缓冲区”，cin从缓冲区取数据给变量进行赋值。
	//   std::cin.ignore();//默认忽略一位
	//   std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
	int num1 = 0; 
	float num2 = 0;
	std::string num3 = "";
	std::cin >> num1;
	std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
	std::cin >> num2;
	std::cin >> num3;
	std::cout << "num1 = " << num1 << ",num2 = " << num2 << ",num3 = " << num3 << std::endl;

	return 0;
}

3.14 369
12.3
abc
num1 = 3,num2 = 12.3,num3 = abc

int main()
{
	// 2.
	int num1 = 0, num2 = 0, num3 = 0;
	std::cin >> num1 >> num2 >> num3;
	std::cout << "num1 = " << num1 << ",num2 = " << num2 << ",num3 = " << num3 << std::endl;

	return 0;

123 456 789
num1 = 123,num2 = 456,num3 = 789

int main()
{
	//3.错误处理
	//  cin内部会维护一个状态，来记录本次的读取操作是否正常
	//  cin.good()
	//  cin.fail()
	//  
	//  如果被标记fail状态，则会影响后续的读取操作
	//  cin.clear()恢复状态，清除错误状态
	int num4 = 0;
	std::cout << "请输入一个整型的数字： ";
	std::cin >> num4;
	std::cout << "num4 = " << num4 << std::endl;
	std::cout << "good = " << std::cin.good() << ",fail = " << std::cin.fail() << std::endl;

	std::cin.clear();
	std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行

	int num5 = 0;
	std::cout << "请输入一个整型的数字： ";
	std::cin >> num5;
	std::cout << "num5 = " << num5 << std::endl;
	std::cout << "good = " << std::cin.good() << ",fail = " << std::cin.fail() << std::endl;

	return 0;
}

请输入一个整型的数字：  abc
num4 = 0
good = 0,fail = 1
请输入一个整型的数字： 123
num5 = 123
good = 1,fail = 0

09.宏定义

#include<iostream>

#define SUCCESS_CODE 0
#define EXPR 2 + 2
#define EXPR2 (2 + 2) 

int main() {

	//std::cout << 0 << std::endl;
	std::cout << "SUCCESS_CODE : " << SUCCESS_CODE << std::endl;

	//std::cout << 2 + 2 << std::endl;
	std::cout << "EXPR : " << EXPR << std::endl;

	//std::cout << 2 + 2 * 2 + 2 << std::endl;
	std::cout << "EXPR * EXPR : " << EXPR * EXPR << std::endl;

	//std::cout << (2 + 2) * (2 + 2) << std::endl;
	std::cout << "EXPR2 * EXPR2 : " << EXPR2 * EXPR2 << std::endl;
	 
	return 0;
}

SUCCESS_CODE : 0
EXPR : 4
EXPR * EXPR : 8
EXPR2 * EXPR2 : 16

10.命名空间

#include <iostream>

//定义一个命名空间
namespace a {
	int num1 = 10;

	//命名空间可以嵌套命名空间
	namespace a1 {
		std::string str = "hello world";
	}
}

namespace b {
	int num1 = 10;
}

//命名空间是开放的，可以随时随地的向一个命名空间中添加成员
namespace a {
	int num2 = 100;
}

namespace constant1 {
	const int MAX_SCORE = 100;
}

namespace constant2 {
	const int MAX_SCORE = 150;
}

int main() {

	//1.命名空间基础的使用
	std::cout << "1.命名空间基础的使用" << std::endl;
	std::cout << a::num1 << std::endl;
	std::cout << b::num1 << std::endl;
	std::cout << a::a1::str << std::endl;
	std::cout << a::num2 << std::endl;

	//2.using指定命名空间中的指定成员
	std::cout << "2.using指定命名空间中的指定成员" << std::endl;
	using a::num1;
	std::cout << num1 << std::endl;
	std::cout << a::num2 << std::endl;

	//3.using命名空间
	std::cout << "3.using命名空间" << std::endl;
	using namespace a;
	std::cout << num1 << std::endl;
	std::cout << num2 << std::endl;
	std::cout << a1::str << std::endl;

	using namespace std;
	cout << num2 << endl;

	//4.注意事项
	//  1.如果引用的命名空间中存在和当前的命名空间中同名字的成员，默认使用当前命名空间中的成员。
	//  2.如果引用的多个命名空间中存在相同名字的成员，且当前的命名空间中没有这个成员，此时会出现二义性。
	std::cout << "4.注意事项" << std::endl;
	const int MAX_SCORE = 200;
	cout << MAX_SCORE << endl;

	using namespace constant1;
	using namespace constant2;
	cout << constant1::MAX_SCORE << endl;
	cout << constant2::MAX_SCORE << endl;

	return 0;
}

1.命名空间基础的使用
10
10
hello world
100
2.using指定命名空间中的指定成员
10
100
3.using命名空间
10
100
hello world
100
4.注意事项
200
100
150

11.算术运算符

#include <iostream>

using namespace std;

int main() {
	// 算术运算符：对数字类型（整型、浮点型、字符型）的数据进行运算
	// +	: 加法运算
	// -	: 减法运算
	// *	: 乘法运算
	// /	: 除法运算
	// %	: 模运算（求余数）
	// 
	// 注意事项：整型与整型的计算结果，还是整型。如果出现了浮点的计算结果，会自动将浮点的结果类型转换成整型。

	cout << "10 + 3 = " << 10 + 3 << endl;
	cout << "10 - 3 = " << 10 - 3 << endl;
	cout << "10 * 3 = " << 10 * 3 << endl;
	cout << "10 / 3 = " << 10 / 3 << endl;
	cout << "10 / 3.0 = " << 10 / 3.0 << endl;
	cout << "10.0 / 3 = " << 10.0 / 3 << endl;
	cout << "10.0 / 3.0 = " << 10.0 / 3.0 << endl;
	cout << "10 % 3 = " << 10 % 3 << endl;


	// ++	: 自增运算符，只能操作一个变量，表示对这个变量的值在现有的基础上 +1
	// --	: 自减运算符，只能操作一个变量，表示对这个变量的值在现有的基础上 -1

	// 注意事项：自增自减运算符，可以放在变量前，也可以放在变量后。
	// 放在变量前：代表先对变量进行自增自减的操作，然后取自增自减之后的值来使用。
	// 放在变量后：代表先取变量的值使用，然后再进行自增自减的操作。

	int num = 10;
	cout << num++ << endl;
	cout << num-- << endl;
	cout << num << endl;

	// 小练习：
	// 在控制台输入一个三位的数字，输出每一位的数字的和。例如：输入123，输出6
	// TIPS：不用考虑用户输入错误，需要重新输入；也不需要考虑用户输入的不是一个三位数。
	int number = 0;
	cout << "请输入一个三位的数字：";
	cin >> number;

	int g = number % 10;
	int s = number / 10 % 10;
	int b = number / 100;

	cout << g + s + b << endl;

	return 0;
}

10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3
10 / 3.0 = 3.33333
10.0 / 3 = 3.33333
10.0 / 3.0 = 3.33333
10 % 3 = 1
10
11
10
请输入一个三位的数字：153
9

12.赋值运算符

#include<iostream>

using namespace std;

int main() {

	// 赋值运算符 = 
	// 将等号右边的值，给左边的变量进行赋值。
	// 注意事项：在C++中，=是赋值的作用，不是用来判断两个数字是否相等的！
	int a = 10;
	a = 20;

	// 1.赋值运算符，也是有运算结果的，运算的结果就是赋值完成之后的变量的值。
	cout << (a = 200) << endl;
	cout << a << endl;

	// 2.组合运算符，将赋值运算符和其它的运算符组合在一起
	int num = 10;

	num += 10;		// 在现有值的基础上进行+10的操作，相当于 num = (int)(num + 10);
	num -= 10;		// num = (int)(num - 10);
	num *= 10;		// num = (int)(num * 10);
	num /= 10;		// num = (int)(num / 10);
	num %= 3;		// num = (int)(num % 3);

	char c = 'a';	// c = (char)(c + 2)
	cout << (c += 2) << endl;

	return 0;
}

200
200
c

13.关系运算符

#include<iostream>

using namespace std;

int main() {

	// 关系运算符：
	// 对两个变量进行大小关系的比较，最后的比较结果一定是布尔类型的。
	// > < >= <= == !=

	cout << (10 > 2) << endl;
	cout << (10 >= 10) << endl;
	cout << (10 == 20) << endl;

	return 0;
}

1
1
0

14.逻辑运算符

#include<iostream>

using namespace std;

int main() {

	// 位运算符

	// & | ^ ~
	// 13 = 0000 1101
	// 21 = 0010 0101
	// ~:按位取反，将每一位的数字都取反（0变成1,1变成0），包括符号位。

	cout << (13 & 21) << endl;	// 0000 0101  => 5
	cout << (13 | 21) << endl;	// 0010 1101  => 16 + 8 + 4 + 1 => 29
	cout << (13 ^ 21) << endl;	// 0010 1000  => 16 + 8 => 24
	cout << ~13 << endl;		// 1111 0010  => 1000 1110 => -14

	// << : 位左移运算符，将补码中的每一位依次向左移动指定的位数，左边溢出的部分舍去，右边补0
	// >> : 位右移运算符，将补码中的每一位依次向右移动指定的位数，右边溢出的部分舍去，左边补符号位
	//
	// 逻辑体现：每向左移动一位，相当于乘了一个2；每向右移动一位，相当于除了一个2
	// 与前面的除法运算符不同，结果是向下取整的
	cout << (13 << 2) << endl;	// 0000 1101  <<2 => 0011 0100 => 32 + 16 + 4 => 52    
	cout << (13 >> 2) << endl;	// 0000 1101  >>2 => 0000 0011 => 2 + 1 => 3  
	cout << (-13 >> 2) << endl;

	// 如何高效率的计算8 * 2
	cout << (8 * 2) << endl;
	cout << (8 << 1) << endl;
	cout << (2 << 3) << endl;
	
	return 0;
}

0
1
0
1
0
result = 0,num1 = 11,num2 = 20

15.位运算符

#include<iostream>

using namespace std;

int main() {

	// 位运算符

	// & | ^ ~
	// 13 = 0000 1101
	// 21 = 0010 0101
	// ~:按位取反，将每一位的数字都取反（0变成1,1变成0），包括符号位。

	cout << (13 & 21) << endl;	// 0000 0101  => 5
	cout << (13 | 21) << endl;	// 0010 1101  => 16 + 8 + 4 + 1 => 29
	cout << (13 ^ 21) << endl;	// 0010 1000  => 16 + 8 => 24
	cout << ~13 << endl;		// 1111 0010  => 1000 1110 => -14

	// << : 位左移运算符，将补码中的每一位依次向左移动指定的位数，左边溢出的部分舍去，右边补0
	// >> : 位右移运算符，将补码中的每一位依次向右移动指定的位数，右边溢出的部分舍去，左边补符号位
	//
	// 逻辑体现：每向左移动一位，相当于乘了一个2；每向右移动一位，相当于除了一个2
	// 与前面的除法运算符不同，结果是向下取整的
	cout << (13 << 2) << endl;	// 0000 1101  <<2 => 0011 0100 => 32 + 16 + 4 => 52    
	cout << (13 >> 2) << endl;	// 0000 1101  >>2 => 0000 0011 => 2 + 1 => 3  
	cout << (-13 >> 2) << endl;

	// 如何高效率的计算8 * 2
	cout << (8 * 2) << endl;
	cout << (8 << 1) << endl;
	cout << (2 << 3) << endl;
	
	return 0;
}

16.三目运算符

#include<iostream>

using namespace std;

int main() {

	// 三目运算符:
	// condition ? value1 : value2
	// condition:是一个bool类型的变量，或者是bool运算结果的表达式。
	// 运算逻辑：如果condition的值为true,整体的结果取value1,否则就取value2。

	cout << (true ? 10 : 20) << endl;
	cout << (false ? 10 : 20) << endl;

	int num1 = 0, num2 = 0;
	cout << "请输入一个整型的数字：";
	cin >> num1;
	cout << "请在输入一个整型的数字：";
	cin >> num2;

	cout << "最大的数字为：" << (num1 > num2 ? num1 : num2) << endl;
	cout << "最小的数字为：" << (num1 < num2 ? num1 : num2) << endl;

	return 0;
}

10
20
请输入一个整型的数字：20
请在输入一个整型的数字：12
最大的数字为：20
最小的数字为：12

良辰美景好时光

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
c++程序设计学习-1【基础语法部分】

c++程序设计学习-1【基础语法部分】
复制链接

扫一扫

专栏目录