关键点
- 整数类型具有可以处理的固定值范围。
- 如果计算超出可以处理的范围,溢出并且计算无法正确执行。
- 当你想处理大于int类型的值时
int64_t使用类型 - 要指定输出双精度型值时小数点后的位数,请执行以下操作: 使用
cout << fixed << setprecision(桁数);
(型)値进行类型转换 (演员表)可以做到- 可能会发生隐式转换
数値型
这次我们将处理整数类型,但具体行为可能会因环境而异。 此页面上编写的内容旨在在 AtCoder 上作为“C++ (GCC 9.2.1)”执行。
int64_t 类型
到目前为止,我们在处理整数时都使用了int类型,但是int类型可以表示的范围仅限于以下范围。
- 最小値:-2147483648
- 最大値:2147483647
计算过程中可能会超出此范围。溢出。如果溢出,计算将无法正确执行。 由于
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 2000000000;
int b = a * 2;
cout << b << endl;
int c = (a * 10 + 100) / 100;
cout << c << endl;
}
実行結果
-294967296 -14748363
2000000000 * 2我想输出4000000000,
输出值-294967296。
另外,
如果(2000000000 * 10 + 100) / 100的结果计算正确,200000001,所以看起来不会溢出,但是
由于计算结果超出了2000000000 * 10处int类型的范围,所以最终的计算结果也是不正确的。
输出值-14748363。
如果您想处理更广泛的值,
通常使用int64_t 类型。
int64_t类型可以处理的值范围如下。
- 最小値:-9223372036854775808
- 最大値:9223372036854775807
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t a = 2000000000;
int64_t b = a * 2;
cout << b << endl;
}
実行結果
4000000000
请记住,int 类型最多可以容纳大约 20 亿(2 * 10^9),如果您可能获得更大的值,请使用 int64_t 类型。
有一些方法可以处理大于 int64_t 类型的值,但我们在这里不讨论它们。如果您有兴趣,请查看一下。
直接在程序中
如果你写一个像10这样的值,它将被视为int类型数字。
如果你希望它被视为 int64_t 类型,
最后,就像10LL添加LL。
另外,int类型和int64_t类型的计算结果变为int64_t类型。
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << 2000000000 * 2 << endl; // int * int -> int
cout << 2000000000LL * 2LL << endl; // int64_t * int64_t -> int64_t
cout << 2000000000LL * 2 << endl; // int64_t * int -> int64_t
}
実行結果
-294967296 4000000000 4000000000
双类型输出
输出double类型时,如果照常使用cout输出,则会四舍五入到适当的位数并显示。
如果要保证中间数字显示时不进行四舍五入,则写如下。
cout << fixed << setprecision(桁数);
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << 3.14159265358979 << endl;
// 小数点以下10桁まで
cout << fixed << setprecision(10);
cout << 3.14159265358979 << endl;
}
実行結果
3.14159 3.1415926536
显式数字类型之间的转换
某些情况下,不同类型之间可以进行计算,例如int类型与int64_t类型之间计算结果为int64_t类型,或者int类型与double类型之间计算结果为double类型。
您也可以只转换类型而不进行任何计算。关于类型转换演员表称为缩进。
C++ 有多种类型转换方法,但这里我们将介绍最原始的一种。
铸造的符号如下。
(型)値
下面是转换数值类型的示例。
#include <bits/stdc++.h>
using namespace std;
int main() {
// 小数点以下5桁まで
cout << fixed << setprecision(5);
int a = 5;
cout << (double)a << endl; // int型の値をdouble型に変換
double b = 3.141592;
cout << (int)b << endl; // double型の値をint型に変換
}
実行結果
5.00000 3
在输出的第一行中,通过将int类型值转换为double类型,输出时也显示小数点后的数字。
在输出的第二行中,double类型的值被转换为int类型,因此小数部分被截断并显示为整数。
重要的是要记住,当您将 double 类型转换为 int 类型时,小数位将被截断。
可以转换各种类型,而不仅仅是 int 和 double 类型。
但是请注意,向非数值类型的转换,例如从int类型到string类型的转换,基本上是不可能的。
int N = 12345; string S = (string)N; // コンパイルエラー
数值类型之间的隐式转换
计算过程中可能会自动进行转换。
不同数值类型之间进行计算时,按下表所示进行铸造后进行计算。
| 类型组合 | 隐式强制转换 | 计算结果类型 |
|---|---|---|
| int类型和double类型 | int 类型 → double 类型 | 双型 |
| int 类型和 int64_t 类型 | int 类型 → int64_t 类型 | int64_t 类型 |
| double 类型和 int64_t 类型 | int64_t 类型 → double 类型 | 双型 |
在以下情况下也会自动进行投射:
- 尝试分配给其他类型的变量时
- 将另一种类型的值传递给函数参数时
以下程序是隐式转换的示例。
#include <bits/stdc++.h>
using namespace std;
void print_int(int x) {
cout << "x = " << x << endl;
}
int main() {
double a = 1.2345;
int b = 1;
// aがdouble型に変換されてからbとの足し算が行われる
// cout << a + (double)b << endl; と同じ結果
cout << a + b << endl;
int c = 2000000000;
int64_t d = 100;
// 初めにcがint64_t型へ変換されてからdとの掛け算が行われる
// cout << (int64_t)c * d << endl; と同じ結果
cout << c * d << endl;
double e = 3.141592;
int f = e; // ここでdouble型からint型への変換が起こる(小数点以下が切り捨てられて3になる)
cout << f << endl;
// int型を引数に取る関数にdouble型を渡す
print_int(e); // int型に変換されてから関数が実行される
}
実行結果
2.2345 200000000000 3 x = 3
即使满足上述条件,如果无法执行强制转换,也会出现编译错误。
#include <bits/stdc++.h>
using namespace std;
void print_int(int x) {
cout << "x = " << x << endl;
}
int main() {
string s = "12345";
int x = s; // コンパイルエラー
print_int(s); // コンパイルエラー
}
即使将不同类型的值传递给函数参数,STLmin功能和
请注意,某些函数(例如max函数)不执行隐式类型转换。
有关详细信息,请参阅第 4 章中的“模板”。
详情
双精度型的精度和误差
让我们简单解释一下 double 类型的内部原理。 double 类型具有“数字序列”和“小数点位置”来处理十进制数。 并且,与 int 类型一样,“数字序列”中可以保存的位数也有上限。 double 类型可以保存大约 16 位数字的序列。反之,超过16位的十进制数就无法准确处理。
由于可表示的位数有限制,因此在执行计算时可能会出现错误。
现实中,可能很少有情况需要担心准确性,但这里我们将解释信息损失和精度损失。
信息故障
考虑将两个差异极大的数字相加。 请看一下下面的程序。
#include <bits/stdc++.h>
using namespace std;
int main() {
double x = 1000000000;
double y = 0.000000001;
// 1000000000.000000001 を表現するには19桁分必要 → 扱えない
double z = x + y; // yの分が消えてしまう
cout << fixed << setprecision(16);
cout << "x: " << x << endl;
cout << "y: " << y << endl;
cout << "z: " << z << endl;
}
実行結果
x: 1000000000.0000000000000000 y: 0.0000000010000000 z: 1000000000.0000000000000000
即使每个要相加的数字都可以用双精度处理,它们相加后的值也可能无法表示。 在这种情况下,数字将会消失。 这种现象 它被称为信息故障。
通过从尽可能小的数字开始添加数字,可以减少信息丢失的影响。
减少损失
考虑减去两个差异极小的数字。
x, y 原本是无限位数的十进制数。 假设当你尝试在计算机上处理这些时,它最多只能表示 6 位数字,之后的数字都是 0。
当使用double类型时,它最多可以处理大约16位数字,但为了解释起见,我们假设它最多只能表示6位数字。
| 实际值 | 计算机上的值 | |
|---|---|---|
| x | 0.1234567890123... | 0.123456 |
| y | 0.1233456789012... | 0.123345 |
现在考虑 z = x - y。
| 实际值 | 计算机上的值 | |
|---|---|---|
| z = x - y | 0.0001111111111... | 0.000111 |
z的真实值为0.0001111111111...但计算结果为0.000111。 您可以看到,尽管使用精度高达 5 位的数字进行计算,但计算结果的精度为 3 位(3 个数字的序列)。
需要注意的是,以这种方式减去差异极小的数字时,值的准确性会降低。减少损失。
如果继续计算,由于数字丢失导致精度降低,最终计算结果的误差可能会增加。
执行减法时,需要设计计算顺序以使差异尽可能大,或者首先尽可能避免减法。
用 printf 输出 您也可以通过调用函数
printf来输出它。
当指定精度或输出大量值时,使用 printf 函数比 cout 更方便。
#include <bits/stdc++.h>
using namespace std;
int main() {
int x = 12345;
double pi = 3.14159265358979;
printf("x = %d, pi = %lf\n", x, pi);
}
実行結果
x = 12345, pi = 3.141593
printf的用法如下。
printf(フォーマット文字列, 埋め込みたい値1, 埋め込みたい値2, ...)
对于“格式字符串”部分,您可以自由指定包含格式说明符的字符串,稍后将对此进行解释。 “要嵌入的值”将按顺序嵌入到您编写格式说明符的部分。
在上面的示例程序中,
它被指定为"x = %d, pi = %lf\n"。
%d呀%lf部分是格式说明符。
第一个%d是x的内容被嵌入,第二个%lf是pi的内容将被嵌入。
此外,\n表示换行符。
格式说明符
根据要嵌入的值的类型,您需要使用相应的格式说明符,典型的格式说明符如下表所示。
| 型 | 格式说明符 |
|---|---|
| 整数 | %d |
| int64_t | %ld(%lld) |
| 双 | %lf |
| 字符 | %c |
在 32 位系统上 当使用
int64_t的printf输出时,格式说明符为 必须是%lld。
如果要输出string类型的字符串,需要这样写。
#include <bits/stdc++.h>
using namespace std;
int main() {
string s = "hello";
// フォーマット指定子 %s を用い s.c_str() を渡す
printf("%s\n", s.c_str());
}
実行結果
hello
此外,通过更改格式说明符部分,您可以更改输出方法,例如要输出的小数位数。
#include <bits/stdc++.h>
using namespace std;
int main() {
double pi = 3.14159265358979;
// %.桁数f とすると小数点以下「桁数」だけ出力される
printf("%.10lf\n", pi);
int x = 1;
int y = 99;
int z = 123;
// %0桁数d とすると表示桁数が「桁数」に満たない場合に0埋めされる
printf("%03d, %03d, %03d\n", x, y, z);
}
実行結果
3.1415926536 001, 099, 123
printf 还有很多功能这里没有介绍。如果您想了解更多,请查看一下。
在scanf中输入 您还可以使用名为
scanf的函数接收输入。
以下是如何使用
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
double pi;
// scanfによる入力
scanf("x = %d, pi = %lf", &x, &pi);
printf("x = %d, pi = %lf\n", x, pi);
}
入力
x = 12345, pi = 3.141593
実行結果
x = 12345, pi = 3.141593
scanf:
scanf(フォーマット文字列, &変数1, &変数2, &変数3, ...);
在变量传递给参数之前
请注意,&是必需的。
该符号的含义将在“4.05.指针”中讨论。
格式字符串基本上是
与printf相同。
但是,您不能直接输入字符串类型字符串。
在这种情况下
请使用cin。
空白字符的处理 如果指定格式说明符,例如
%d,则将跳过前面的连续空白字符。空白字符是一个空格 ()、改行文字(\n), 制表符 (\t)等
对于如下调用,
如果输入字符串123 456,x 将是 123,y 将是 456。
scanf("%d%d", &x, &y);
使用字符串进行转换
to_string 函数
要从数字类型转换为字符串,
使用to_string功能。
to_string函数将参数的数值转换为字符串类型。
#include <bits/stdc++.h>
using namespace std;
int main() {
int number = 100;
string s = to_string(number);
cout << s + "yen" << endl;
}
実行結果
100yen
stoi 函数
要从 string 类型转换为 int 类型,stoi功能。
#include <bits/stdc++.h>
using namespace std;
int main() {
string s = "100";
int n = stoi(s);
cout << n << endl;
}
実行結果
100
要将字符串转换为其他数字类型,请使用与每种类型对应的函数。 兼容性表如下所示。
| 型 | 字符串转换函数 |
|---|---|
int |
stoi |
int64_t |
stoll |
double |
stod |
如何使用这些功能
与stoi功能相同。
还有其他类型特有的功能,但基本上int64_t类型?double类型然后施放。
其他数字类型
除了 int 和 double 类型之外,还可以使用各种数字类型。 它们的不同之处在于它们可以处理的值的范围、它们的精度以及它们使用的内存量。
整数型
主要有符号整数类型
| 型 | 可处理的值范围 | 使用的内存量 |
|---|---|---|
signed char |
-2^{7} 〜 2^{7}-1 | 1 字节(8 位) |
short |
-2^{15} 〜 2^{15}-1 | 2 字节(16 位) |
int |
-2^{31} 〜 2^{31}-1 | 4 字节(32 位) |
long long |
-2^{63} 〜 2^{63}-1 | 8 字节(64 位) |
int8_t |
-2^{7} 〜 2^{7}-1 | 1 字节(8 位) |
int16_t |
-2^{15} 〜 2^{15}-1 | 2 字节(16 位) |
int32_t |
-2^{31} 〜 2^{31}-1 | 4 字节(32 位) |
int64_t |
-2^{63} 〜 2^{63}-1 | 8 字节(64 位) |
主要无符号整数类型
| 型 | 可处理的值范围 | 使用的内存量 |
|---|---|---|
unsigned char |
0 〜 2^{8}-1 | 1 字节(8 位) |
unsigned short |
0 〜 2^{16}-1 | 2 字节(16 位) |
unsigned int |
0 〜 2^{32}-1 | 4 字节(32 位) |
unsigned long long |
0 〜 2^{64}-1 | 8 字节(64 位) |
uint8_t |
0 〜 2^{8}-1 | 1 字节(8 位) |
uint16_t |
0 〜 2^{16}-1 | 2 字节(16 位) |
uint32_t |
0 〜 2^{32}-1 | 4 字节(32 位) |
uint64_t |
0 〜 2^{64}-1 | 8 字节(64 位) |
int??_t系统和 对于uint??_t以外的系统,该表可能会因环境而异。
对于要使用的内存,例如,long long由于类型是64bit,对于一个变量int您需要两个类型变量的内存。”
太多了,你可能不知道如何正确使用它们。
我们建议使用
int??_t系统和
对于uint??_t系统。
这是一个极端的故事,但如果你不关心使用的内存量,所有int64_t类型?uint64_t另一种选择是使用类型。
実数型
| 型 | 可处理的值范围(绝对值) | 可处理的精度(十进制) | 使用的内存量 |
|---|---|---|---|
float |
約1.17×10^{-38} 〜 約3.40×10^{38} | 約8桁 | 4 字节(32 位) |
double |
約2.22×10^{-308} 〜 約1.79×10^{308} | 約16桁 | 8 字节(64 位) |
环境相关规格
作为整数类型,其可处理范围根据环境而变化。
有long。
下表显示了
long可以处理的范围。
| Windows | Linux | mac OS X | |
|---|---|---|---|
| 32位系统 与 | int32_t相同 |
int32_t相同 |
int32_t相同 |
| 64位系统 | int32_t相同 |
int64_t相同 |
int64_t相同 |
在 AtCoder 上执行时,long可以处理的范围是
它将与int64_t相同。
程序中直接写入的数字long将其视为一种类型,
最后一个,例如10L用L写入。
在 AtCoder 上
int64_t是 由于它被视为long类型,严格来说,不能使用直接在程序中写入的数字。 如果你想将其视为int64_t就像10L喜欢long按照类型来写比较准确,但为了使其在其他系统上也能类似地工作,int64_t将其视为一种类型LL。
尺寸_t
数组和字符串size()返回的元素数量值为
它是无符号整数类型size_t。
在 C++ 中(GCC 9.2.1)
定义为size_t是
由于它被视为unsigned long(只是一个别名)。
## 选角规则 比 int 类型窄的类型首先转换为 int 类型→按照以下规则强制转换根据执行环境,for 语句 当您写入
for (int i = 0; i < 配列.size(); i++)时收到警告的原因是您正在比较 int 类型(有符号)和 size_t 类型(无符号)。 但是,由于强制转换是隐式完成的,因此对操作没有影响。
无符号整数溢出
无符号整数不能处理负数,例如unsigned char类型
从0中减 1
将显示255。
size_t由于该类型是无符号整数类型,因此如下所示的程序将不会按预期运行。
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> data(0); // サイズ0
cout << data.size() - 1 << endl; // -1ではない
// 配列のサイズ-1回だけループしたい
for (int i = 0; i < data.size() - 1; i++) {
cout << i << endl;
}
}
执行结果示例
18446744073709551615 0 1 2 3 4 5 6 7 8 (省略)
在此示例中,循环计数为data.size() - 1溢出
该值为18446744073709551615。
数组大小 - 如果只想循环一次,请使用
您需要将size()的结果转换为签名。
// 配列のサイズ-1回のループ(ただし、空の場合はループ内は実行されない)
for (int i = 0; i < (int)配列.size() - 1; i++) {
// 適当な処理
}
演習問題
这次没有练习题。
尝试解决以下 AtCoder 初学者竞赛问题。