← 返回题目列表

AtCoder · APG4b_y

Y. 3.01.数字类型

中文机器翻译题面 查看原题
page_url:https://atcoder.jp/contests/apg4b/tasks/APG4b_y 任务ID:3771

前一页 | 下一页

关键点

  • 整数类型具有可以处理的固定值范围。
  • 如果计算超出可以处理的范围,溢出并且计算无法正确执行。
  • 当你想处理大于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。

### 关于 scanf 的注释 ##### 失败 如果输入字符串与格式字符串中指定的格式不匹配,则失败。 `scanf` 返回成功读取的变量数量,因此您可以使用该值。 wzxhzdk:30 ##### 输入 wzxhzdk:31 #####执行结果 wzxhzdk:32 > 但是,如果`scanf`由于匹配以外的原因失败,它会返回特殊值`EOF`。 > 为了更准确地判断失败,首先需要判断`scanf`的返回值是否与`EOF`匹配。
空白字符的处理 如果指定格式说明符,例如

%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(只是一个别名)。

根据执行环境,for 语句 当您写入for (int i = 0; i < 配列.size(); i++)时收到警告的原因是您正在比较 int 类型(有符号)和 size_t 类型(无符号)。 但是,由于强制转换是隐式完成的,因此对操作没有影响。

## 选角规则 比 int 类型窄的类型首先转换为 int 类型→按照以下规则强制转换

无符号整数溢出

无符号整数不能处理负数,例如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 初学者竞赛问题。

前一页 | 下一页