#创作计划#福州线上小码王笔记（随时跟新

AC是最好的

2025-08-03 11:21:39

发布于：福建

36阅读

0回复

0点赞

U1-1：初识C++（本作品参考很多笔记和作者老师给的课件）

认识单词：
1.main 主要 2. world 世界 3.include 包含 4.return 返回

#include <iostream>//这个是头文件
using namespace std;//命名空间
int main(){
    
    return 0;
}

1.什么是头文件？—— 头文件你可以理解成一个工具箱，里面装着很多工具也就是我们像iostream，string，cstring，algorithm等很多工具。
2.命名空间有什么用？——举个栗子，我有个好朋友叫李华，有一天我买了两杯手打柠檬汁，一杯给我，一杯给他，但二班也有个叫李华的同学，可我却不认识他，我和我的好朋友李华混淆了，这时候就用

using lihua std;//这不是真的哈，我只是举个栗子的使用

当然不写using namespace std；其实也行，那你有些代码前面要加上std::
比如铺地毯这题
你加上using namespace std；这个玩意是这样写的

#include <bits/stdc++.h>
using namespace std;
long long n, x, y;
const long long N = 101100;
long long a [N], b[N], c[N], d[N];
int main() {
	cin >> n;
	for (int i = 1 ; i <= n ; i++) {
		scanf ("%d%d%d%d", &  a[i], & b[i], & c[i], & d[i]);
		
	}
	scanf ("%d%d", &x, &y);
	long long color = 0;
	for (int j = n ; j >= 1 ; j--) {
		if (a[j] <= x && c[j] + a[j] >= x && b[j] <= y &&  b[j] + d[j] >= y) {
			color = j;
			break;
		}
	}
	cout << color;
	return 0;
}

没加using namespace std；是这样的

#include <bits/stdc++.h>
long long n, x, y;
const long long N = 101100;
long long a [N], b[N], c[N], d[N];
int main() {
	std::cin >> n;
	for (int i = 1 ; i <= n ; i++) {
		scanf ("%d%d%d%d", &  a[i], & b[i], & c[i], & d[i]);
		
	}
	scanf ("%d%d", &x, &y);
	long long color = 0;
	for (int j = n ; j >= 1 ; j--) {
		if (a[j] <= x && c[j] + a[j] >= x && b[j] <= y &&  b[j] + d[j] >= y) {
			color = j;
			break;
		}
	}
	std::cout << color;
	return 0;
}

是不是在19行和第6行多了一个std::这个东西，你不加会报错
然后你们看见了我在第一行写了这个东西

#include <bits/stdc++.h>

这个你可以理解成这个是个什么都有的工具箱

A1-1.输入输出

输出：
如果项目是表达式，直接输出表达式结果（除非你太闲了！！！）：
A-1：输出3+4的和

cout << 3 + 4;

如果项目有双引号则直接输出双引号里的东西
A-2：输出“欢迎来到ACGO”（不含引号）

cout << "欢迎来到ACGO";

综合练习：输出202520-8/10的结果
输入样例：无
输出样例：202520-8/10 = （自己想去！！！）

#include <bits/stdc++.h>
using namespace std;
int main(){
    cout << "2025*20-8/10 = " << 2025*20-8/10;
    return 0;
}

如果你想学习怎么输入首先要先学习什么是变量
什么是变量？——变量是一个存储数据的容器
声明变量：

//数据类型  变量名
    int       a;

区分大小写，意思是大写和小写是不同的，
所以teacher、Teacher、TEACHER是三
个不同的名字
变量名不能以数字开头，所以4name
不能作为变量名
变量名不能包含空格
可以给变量取名为你喜欢的名字。名字长短由你来定，里面可以有字母、数字和下划线（_）。
变量名不能和关键字重名

cin >> 变量1 >> 变量2 >> … >> 变量n;
1 cin语句把空格字符和回车换行符作为分隔符，不输入给变量
2 cin语句忽略多余的输入数据

在声明变量时，可以将变量声明在main函数内部也可以将变量声明到main函数外部。在main函数里面的变量被称为局部变量，在main函数之外的变量被称之为全局变量。对于全局变量而言，如果不在变量声明的时候进行初始化操作，系统将会自动将全局变量赋值为0。全局变量和本地变量最大的区别就是其作用域不同，本书的后半部分将会提及变量的作用域。

而赋值时会有两种方法
1.

#include <bits/stdc++.h>
using namespace std;
int main(){
    long long number;
    number = 666;
    return 0;
}

也可以边定义边赋值

#include <bits/stdc++.h>
using namespace std;
int main(){
    long long number = 666;
    return 0;
}

注释：单行注释是\，多行注释就是/**/看下面

#include <bits/stdc++.h>
using namespace std;
int main(){
    //这是一个注释
    int a;
    /*
    这也是一个注释
    */
    cout << a;
    return 0;
}

例二：交换两个变量：
交换两个变量的值：
1.

#include <bits/stdc++.h>
using namespace std;
int main(){
    long long a , b ,  c;
    cin >> a >> b >> c;
    c = a;
    a = b;
    b = c; 
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main(){
    long long a , b ,  c;
    cin >> a >> b >> c;
    a = a + b;
    b = a – b;
    a = a – b;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main(){
    long long a , b;
    cin >> a >> b;
    swap(a , b);
    return 0;
}

A1-2:变量的一些知识

$\begin{equation*} 基本类型 \begin{cases} short 短整型 \\ int 基本整型\\ long长整数\\ long long 超长整数 \\ float 单精度\\ double 双精度\\ long double 超长精度\\ char 字符\\ bool 布尔类型\\ enum 枚举类型\\ type* 指针类型\\ type[]或type[size] 数组类型\\ struct 结构体类型\\ class类类型\\ union共用体类型 \end{cases} \end{equation*}$

数据类型	描述	大小（字节）	范围/取值示例
bool	布尔类型，表示真或假	1	true 或 false
char	字符类型，通常用于存储 ASCII 字符	1	-128 到 127 或 0 到 255
signed char	有符号字符类型	1	-128 到 127、
unsigned char	无符号字符类型	1	0 到 255
wchar_t	宽字符类型，用于存储 Unicode 字符	2 或 4	取决于平台
char16_t	16 位 Unicode 字符类型（C++11 引入）	2	0 到 65,535
char32_t	32 位 Unicode 字符类型（C++11 引入）	4	0 到 4,294,967,295
short	短整型	2	-32,768 到 32,767
unsigned short	无符号短整型	2	0 到 65,535
int	整型	4	-2,147,483,648 到 2,147,483,647
unsigned int	无符号整型	4	0 到 4,294,967,295
long	长整型	4 或 8	取决于平台
unsigned long	无符号长整型	4 或 8	取决于平台
long long	长长整型（C++11 引入）	8	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long long	无符号长长整型（C++11 引入）	8	0 到 18,446,744,073,709,551,615
float	单精度浮点数	4	约 ±3.4e±38（6-7 位有效数字）
double	双精度浮点数	8	约 ±1.7e±308（15 位有效数字）
long double }	扩展精度浮点数	8、12 或 16	取决于平台

C++11新增加类型：

数据类型	描述	示例
auto	自动类型判断	auto x =10;
decltype	获取表达式的类型	decltype(x) y = 20;
nullptr	空指针常量	int* ptr = nullptr;
std::initializer_list	初始化列表类型	std::initializer_list<int> list = {1, 2, 3};
std::tuple	元组类型，可以存储多个不同类型的值	std::tuple<int, float, char> t(1, 2.0, 'a');

下面实例会输出您电脑上各种数据类型的大小。

#include<iostream>  
#include <limits>
 
using namespace std;  
  
int main()  
{  
    cout << "type: \t\t" << "************size**************"<< endl;  
    cout << "bool: \t\t" << "所占字节数：" << sizeof(bool);  
    cout << "\t最大值：" << (numeric_limits<bool>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<bool>::min)() << endl;  
    cout << "char: \t\t" << "所占字节数：" << sizeof(char);  
    cout << "\t最大值：" << (numeric_limits<char>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<char>::min)() << endl;  
    cout << "signed char: \t" << "所占字节数：" << sizeof(signed char);  
    cout << "\t最大值：" << (numeric_limits<signed char>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<signed char>::min)() << endl;  
    cout << "unsigned char: \t" << "所占字节数：" << sizeof(unsigned char);  
    cout << "\t最大值：" << (numeric_limits<unsigned char>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<unsigned char>::min)() << endl;  
    cout << "wchar_t: \t" << "所占字节数：" << sizeof(wchar_t);  
    cout << "\t最大值：" << (numeric_limits<wchar_t>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<wchar_t>::min)() << endl;  
    cout << "short: \t\t" << "所占字节数：" << sizeof(short);  
    cout << "\t最大值：" << (numeric_limits<short>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<short>::min)() << endl;  
    cout << "int: \t\t" << "所占字节数：" << sizeof(int);  
    cout << "\t最大值：" << (numeric_limits<int>::max)();  
    cout << "\t最小值：" << (numeric_limits<int>::min)() << endl;  
    cout << "unsigned: \t" << "所占字节数：" << sizeof(unsigned);  
    cout << "\t最大值：" << (numeric_limits<unsigned>::max)();  
    cout << "\t最小值：" << (numeric_limits<unsigned>::min)() << endl;  
    cout << "long: \t\t" << "所占字节数：" << sizeof(long);  
    cout << "\t最大值：" << (numeric_limits<long>::max)();  
    cout << "\t最小值：" << (numeric_limits<long>::min)() << endl;  
    cout << "unsigned long: \t" << "所占字节数：" << sizeof(unsigned long);  
    cout << "\t最大值：" << (numeric_limits<unsigned long>::max)();  
    cout << "\t最小值：" << (numeric_limits<unsigned long>::min)() << endl;  
    cout << "double: \t" << "所占字节数：" << sizeof(double);  
    cout << "\t最大值：" << (numeric_limits<double>::max)();  
    cout << "\t最小值：" << (numeric_limits<double>::min)() << endl;  
    cout << "long double: \t" << "所占字节数：" << sizeof(long double);  
    cout << "\t最大值：" << (numeric_limits<long double>::max)();  
    cout << "\t最小值：" << (numeric_limits<long double>::min)() << endl;  
    cout << "float: \t\t" << "所占字节数：" << sizeof(float);  
    cout << "\t最大值：" << (numeric_limits<float>::max)();  
    cout << "\t最小值：" << (numeric_limits<float>::min)() << endl;  
    cout << "size_t: \t" << "所占字节数：" << sizeof(size_t);  
    cout << "\t最大值：" << (numeric_limits<size_t>::max)();  
    cout << "\t最小值：" << (numeric_limits<size_t>::min)() << endl;  
    cout << "string: \t" << "所占字节数：" << sizeof(string) << endl;  
    // << "\t最大值：" << (numeric_limits<string>::max)() << "\t最小值：" << (numeric_limits<string>::min)() << endl;  
    cout << "type: \t\t" << "************size**************"<< endl;  
    return 0;  
}

typedef 声明
您可以使用 typedef 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法：
例如，下面的语句会告诉编译器，LL 是 long long 的另一个名称：

typedef long long LL;

那下面的定义就是合法的

LL number;//定义一个长整型

A1-3:常量（我就浅浅的讲一下，等到写数组时我在详写）：
常量是固定值，在程序执行期间不会改变

const long long a;
const int b;
const long subwsy_time;

A1-4：运算符

运算符	描述
+	把两个操作数相加
-	从第一个操作数中减去第二个操作数
*	把两个操作数相乘
/	分子除以分母
%	取模运算符，整除后的余数
++	自增运算符，整数值增加 1
--	自减运算符，整数值减少 1
==	检查两个操作数的值是否相等，如果相等则条件为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。
>=	+检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。
&&	称为逻辑与运算符。如果两个操作数都 true，则条件为 true
	称为逻辑或运算符。如果两个操作数中有任意一个 true，则条件为 true。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态，如果条件为 true 则逻辑非运算符将使其为 false
=	简单的赋值运算符把右边操作数的值赋给左边操作数 C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 C = A 相当于 C = C A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数
sizeof	sizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。
Condition ? X : Y	条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。
,	逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。
.（点）和 ->（箭头）	成员运算符用于引用类、结构和共用体的成员。
Cast	强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。
&	指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。
*	指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。
&	按位与操作，按二进制位进行"与"运算。
按位或运算符，按二进制位进行"或"运算。运算规则：0	0=0; 0
^	异或运算符，按二进制位进行"异或"运算。运算规则：0^0=0; 0^1=1; 1^0=1; 1^1=0;(A ^ B) 将得到 49，即为 0011 0001
~	取反运算符，按二进制位进行"取反"运算。运算规则：~1=-2; _0=-1;(A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。 A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。
&=	按位与且赋值运算符 C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符 C ^= 2 等同于 C = C ^ 2

类别	运算符	结合性
后缀	()、 [] 、->、 . 、++ 、- -	从左到右
一元	+ 、- 、! 、~ 、++、 - - (type)* & 、sizeof	从右到左
乘除	* 、/、 %	从左到右
加减	+、 -	从左到右
移位	<< 、>>	从左到右
关系	<、<= 、> 、>=	从左到右
相等	== 、!=	从左到右
位与 AND	&	从左到右
位异或 XOR	^	从左到右
位或 OR	从左到右
逻辑与 AND	&&	从左到右
逻辑或 OR		从左到右
条件	?:	从右到左
赋值	= += -= *= /= %=>>= <<= &= ^=	=
逗号	,	从左到右

ASCII 码:

cout << 'A' + 32 << endl;  // 输出结果为：97。

A区例题：
B2002 Hello,World!
题意：啥也别说了，就输出Hello World！即可

#include <bits/stdc++.h>
using namespace std;
int main(){
    string str = "Hello,World!";//这种用变量存储较为麻烦但也是一种办法
    cout << str;//输出str字符串
    return 0;//程序结束
}

有帮助，赞一个

去预览

0/2000

这里空空如也

热门讨论