リテラル
数値および文字列の値をそのまま記述したものをリテラル(literals)と呼びます。 例えば、次のように変数に代入する値として記述している値そのものが数値リテラル・文字列リテラルとなります。
var i = 16; // 数値リテラル
var s = "Hello!, world"; // 文字列リテラル
Dim i As Integer = 16 ' 数値リテラル
Dim s As String = "Hello!, world" ' 文字列リテラル
整数リテラル
数値をそのまま記述した場合、整数リテラルは10進整数として扱われます。 このほか、以下のプレフィックスを前置することにより、16進・8進・2進の各基数表記で整数リテラルを記述することができます。
| プレフィックス | 形式 | |
|---|---|---|
| C# | VB | |
0x
|
&H,&h |
16進整数リテラル |
| - |
&O,&o |
8進整数リテラル |
0b
|
&B,&b |
2進整数リテラル |
このほか、値の型を明示するためにサフィックスを後置することもできます。
16進整数リテラル
C#では数値リテラルにプレフィックス0xを前置することで16進数表記で整数リテラルを記述できます。 桁揃えのために数値の先頭に0を並べることもできます。 また、桁区切り文字としてアンダースコア_を入れることもできます。
using System;
class Sample {
static void Main()
{
var a = 100; // 10進数で表された数値'100'
var b = 0x0100; // 16進数で表された数値'100'
var c = 0xFFFF; // 16進数で表された数値'FFFF'
var d = 0x0000_abcd; // 16進数で表された数値'abcd'
Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(c);
Console.WriteLine(d);
Console.WriteLine();
// 変数の値を16進数の文字列に変換して表示
Console.WriteLine(a.ToString("X"));
Console.WriteLine(b.ToString("X"));
Console.WriteLine(c.ToString("x")); // A-Fを小文字で表記する
Console.WriteLine(d.ToString("X")); // A-Fを大文字で表記する
}
}
VBでは数値リテラルにプレフィックス&Hまたは&hを前置することで16進数表記で整数リテラルを記述できます。 桁揃えのために数値の先頭に0を並べることもできます。 また、桁区切り文字としてアンダースコア_を入れることもできます。
Imports System
Class Sample
Shared Sub Main()
Dim a As Integer = 100 ' 10進数で表された数値'100'
Dim b As Integer = &H0100 ' 16進数で表された数値'100'
Dim c As Integer = &HFFFF ' 16進数で表された数値'FFFF'
Dim d As Integer = &h0000_abcd ' 16進数で表された数値'abcd'
Console.WriteLine(a)
Console.WriteLine(b)
Console.WriteLine(c)
Console.WriteLine(d)
Console.WriteLine()
' 変数の値を16進数表記の文字列に変換して表示
Console.WriteLine(a.ToString("X"))
Console.WriteLine(b.ToString("X"))
Console.WriteLine(c.ToString("x")) ' A-Fを小文字で表記する
Console.WriteLine(d.ToString("X")) ' A-Fを大文字で表記する
End Sub
End Class
100 256 65535 43981 64 100 ffff ABCD
ToStringメソッドによる数値の文字列化と、16進形式の書式指定子Xについては書式指定子 §.X, x (hexadecimal/16進数)を参照してください。
8進整数リテラル
VBでは数値リテラルにプレフィックス&Oまたは&oを前置することで8進数表記で整数リテラルを記述できます。
Imports System
Class Sample
Shared Sub Main()
Dim a As Integer = &O10 ' 8進数で表された数値'10'
Dim b As Integer = &H10 ' 16進数で表された数値'10'
Dim c As Integer = 10 ' 10進数で表された数値'10'
Console.WriteLine(a)
Console.WriteLine(b)
Console.WriteLine(c)
End Sub
End Class
8 16 10
C#では8進数の整数リテラルを記述することはできません。 Convertクラスを用いることにより、8進数文字列⇄数値の変換を行うことができます。
16進整数形式とは異なり、8進数形式に変換する書式指定子は現在のところ定義されていないので、8進数形式で文字列化したい場合はConvertクラスを使用します。
2進整数リテラル
C# 7.0以降では、数値リテラルにプレフィックス0bを前置することで2進数表記で整数リテラルを記述できます。 桁揃えのために数値の先頭に0を並べることもできます。 また、桁区切り文字としてアンダースコア_を入れることもできます。
using System;
class Sample {
static void Main()
{
var a = 100; // 10進数で表された数値'100'
var b = 0b0100; // 2進数で表された数値'100'
var c = 0b1111_1111_1111_1111; // 2進数で表された数値'1111111111111111'
Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(c);
Console.WriteLine();
// 変数の値を2進数表記の文字列に変換して表示
Console.WriteLine(a.ToString("B"));
Console.WriteLine(b.ToString("B"));
Console.WriteLine(c.ToString("B"));
}
}
VB 15以降では、数値リテラルにプレフィックス&Bまたは&bを前置することで2進数表記で整数リテラルを記述できます。 桁揃えのために数値の先頭に0を並べることもできます。 また、桁区切り文字としてアンダースコア_を入れることもできます。
Imports System
Class Sample
Shared Sub Main()
Dim a As Integer = 100 ' 10進数で表された数値'100'
Dim b As Integer = &B0100 ' 2進数で表された数値'100'
Dim c As Integer = &b1111_1111_1111_1111 ' 2進数で表された数値'1111111111111111'
Console.WriteLine(a)
Console.WriteLine(b)
Console.WriteLine(c)
Console.WriteLine()
' 変数の値を2進数表記の文字列に変換して表示
Console.WriteLine(a.ToString("B"))
Console.WriteLine(b.ToString("B"))
Console.WriteLine(c.ToString("B"))
End Sub
End Class
100 4 65535 1100100 100 1111111111111111
2進数形式に変換する書式指定子Bは.NET 8以降で使用できます。 ToStringメソッドによる数値の文字列化と、2進形式の書式指定子Bについては書式指定子 §.B, b (binary/2進数)を参照してください。
それ以前のバージョンで2進数形式に文字列化したい場合はConvertクラスを使用します。
整数リテラルでのオーバーフローチェックの抑止
C#では、代入の結果オーバーフローとなるような値を、メモリ上での表現を維持したまま代入したい場合はuncheckedを用います。
たとえば、値80000000(16) = 2147483648(10)はintで扱える最大値を超えるため、これを単に代入しようとするとオーバーフローとなります。 一方、メモリ上での表現としての80000000(16)はintとして妥当な値です。 こういった場合は、uncheckedによってオーバーフローのチェックをせずに代入させることができます。
using System;
static class Sample {
static void Main()
{
// 16進表記での80000000(10進表記で2147483648)は、intで表現できる最大値(2147483647)を超える値であり、
// オーバーフローとなるため、そのままではコンパイルエラーになる
// メモリ上での表現はそのままでintにキャストさせたい場合は、uncheckedを用いる
// (この結果、メモリ上での表現で0x80000000、10進整数表現で'-2147483648'が代入される)
int hex1 = unchecked((int)0x80000000);
// 32ビットを超える表現となる値をint(32ビット整数型)に代入するような場合もオーバーフローとなる
// この場合、uncheckedを用いてキャストすると、下位32ビットのみが代入される
// (この結果、メモリ上での表現で0x00000000、10進整数表現で'0'が代入される)
int hex2 = unchecked((int)0x100000000);
Console.WriteLine(hex1);
Console.WriteLine(hex2);
}
}
-2147483648 0
数値の型を明示するためにサフィックスを後置することもできます。 サフィックスを指定せず、varによる宣言を行う場合は、値の大きさに応じて型選択が行われます。
Convertクラスによる基数変換
Convertクラスを使うことにより、基数を指定して文字列と数値の相互変換を行うことができます。 これにより、例えば16進数表記の文字列を数値にする、あるいはその逆といったことができます。 基数として指定できる値は、2, 8, 10, 16のいずれかです。
using System;
class Sample {
static void Main()
{
Console.WriteLine("(128)10 = ({0})2", Convert.ToString(128, 2)); // 10進数の値128を2進数で表記された文字列に変換
Console.WriteLine("(128)10 = ({0})16", Convert.ToString(128, 16)); // 10進数の値128を16進数で表記された文字列に変換
Console.WriteLine();
Console.WriteLine("b100 = {0}", Convert.ToInt32("100", 2)); // 文字列"100"を2進数で表された数値としてintに変換
Console.WriteLine("0x100 = {0}", Convert.ToInt32("100", 16)); // 文字列"100"を16進数で表された数値としてintに変換
}
}
Imports System
Class Sample
Shared Sub Main()
Console.WriteLine("(128)10 = ({0})2", Convert.ToString(128, 2)) ' 10進数の値128を2進数で表記された文字列に変換
Console.WriteLine("(128)10 = ({0})16", Convert.ToString(128, 16)) ' 10進数の値128を16進数で表記された文字列に変換
Console.WriteLine()
Console.WriteLine("b100 = {0}", Convert.ToInt32("100", 2)) ' 文字列"100"を2進数で表された数値としてintに変換
Console.WriteLine("&H100 = {0}", Convert.ToInt32("100", 16)) ' 文字列"100"を16進数で表された数値としてintに変換
End Sub
End Class
(128)10 = (10000000)2 (128)10 = (80)16 b100 = 4 0x100 = 256
16進数形式で表記した文字列は、ToStringメソッドに書式指定子Xを指定することでも得られます。 具体例は§.16進整数リテラルを参照してください。
また、.NET 8以降であれば、書式指定子Bを指定することで2進数形式で表記した文字列を得ることができます。 具体例は§.2進整数リテラルを参照してください。
Convertクラスや、他の手段による基数変換についてはビット演算 §.数値・文字列間での基数変換にて詳しく解説しています。
実数リテラル
実数リテラルには、通常の実数表記と、指数表記の二種類があります。 指数表記の場合、仮数部E(+|-)指数部のように記述します。 例えば3.0×108は3.0e8や3.0E+8と記述します。 また、値の型(精度)を明記するためにサフィックスを付けることもできます。
using System;
class Sample {
static void Main()
{
var fpi = 3.14f; // float型・実数表記の実数リテラル
var dpi = 3.14; // double型・実数表記の実数リテラル
// 実数形式・指数形式でそれぞれの値を表示
Console.WriteLine("{0:F}, {0:E}", fpi);
Console.WriteLine("{0:F}, {0:E}", dpi);
}
}
Imports System
Class Sample
Shared Sub Main()
Dim spi As Single = 3.14F ' Single型・実数表記の実数リテラル
Dim dpi As Double = 3.14 ' Double型・実数表記の実数リテラル
' 実数形式・指数形式でそれぞれの値を表示
Console.WriteLine("{0:F}, {0:E}", spi)
Console.WriteLine("{0:F}, {0:E}", dpi)
End Sub
End Class
3.140, 3.140000E+000 3.140, 3.140000E+000
using System;
class Sample {
static void Main()
{
var fc = 3.0e+8f; // float型・指数表記の実数リテラル(3.0×10^8)
var dc = 3.0e+8; // double型・指数表記の実数リテラル(3.0×10^8)
var fg = 9.80665e-2f; // 9.80665×10^-2
var dg = 9.80665e-2; // 9.80665×10^-2
// 実数形式・指数形式でそれぞれの値を表示
Console.WriteLine("{0:F}, {0:E}", dc);
Console.WriteLine("{0:F}, {0:E}", dg);
}
}
Imports System
Class Sample
Shared Sub Main()
Dim sc As Single = 3.0E+8F ' float型・指数表記の実数リテラル(3.0×10^8)
Dim dc As Double = 3.0E+8 ' double型・指数表記の実数リテラル(3.0×10^8)
Dim sg As Single = 9.80665E-2F ' 9.80665×10^-2
Dim dg As Double = 9.80665E-2 ' 9.80665×10^-2
' 実数形式・指数形式でそれぞれの値を表示
Console.WriteLine("{0:F}, {0:E}", dc)
Console.WriteLine("{0:F}, {0:E}", dg)
End Sub
End Class
300000000.00, 3.000000E+008 0.10, 9.806650E-002
Console.WriteLineメソッドでの数値の文字列化と、実数形式の書式指定子Fおよび指数形式の書式指定子Eについては、書式指定子 §.F, f (fixed-point/固定小数点)・書式指定子 §.E, e (exponential/指数)を参照してください。
数値リテラルでの桁区切り文字
C#7以降、VB.NET 15以降では、アンダースコア_を桁区切り文字として使用することができます。 桁区切り文字は、整数リテラルや実数リテラルに対して使うことができます。 特に2進数リテラルや実数リテラルなど、桁数が多くなりやすい数値リテラルでは、桁区切り文字を用いることで読みやすくすることができます。
一般的な数値の表記におけるカンマ,とは異なり、桁区切り文字_は3桁や4桁ごとに限らず、任意の位置に入れることができます。 また、場合によっては連続させることもできます。 0xなどのプレフィックスと数値の間には桁区切り文字を入れることができますが、数値とサフィックスの間に入れることはできません。
using System;
class Sample {
static void Main()
{
var i1 = 0b0000_1111_0000_1111; // 2進数リテラルと桁区切り文字
var i2 = 1_2__346_5789; // 任意の桁数ごとに区切りを入れたり、区切りを連続させることもできる
var i3 = 0b_0_01_001___1; // プレフィックス(0b)と数値の間にも区切りを入れることができる
var u = 0x_1_0_0u; // 数値とサフィックス(u)の間には区切りを入れることはできない
var pi = 3.141_592f; // 実数リテラル(float)と桁区切り文字
var c = 2.99_792_458e+8; // 実数リテラル(double, 指数形式)と桁区切り文字
Console.WriteLine(i1);
Console.WriteLine(i2);
Console.WriteLine(i3);
Console.WriteLine(u);
Console.WriteLine(pi);
Console.WriteLine(c);
}
}
Option Infer On
Imports System
Class Sample
Shared Sub Main()
Dim i1 = &B0000_1111_0000_1111 ' 2進数リテラルと桁区切り文字
Dim i2 = 1_2__346_5789 ' 任意の桁数ごとに区切りを入れたり、区切りを連続させることもできる
Dim i3 = &B_0_01_001___1 ' プレフィックス(&B)と数値の間にも区切りを入れることができる
Dim u = &H_1_0_0UI ' 数値とサフィックス(UI)の間には区切りを入れることはできない
Dim pi = 3.141_592F ' 実数リテラル(Single)と桁区切り文字
Dim c = 2.99_792_458E+8 ' 実数リテラル(Double, 指数形式)と桁区切り文字
Console.WriteLine(i1)
Console.WriteLine(i2)
Console.WriteLine(i3)
Console.WriteLine(u)
Console.WriteLine(pi)
Console.WriteLine(c)
End Sub
End Class
3855 123465789 19 256 3.141592 299792458
文字・文字列のリテラル
C#およびVBでは、二重引用符・ダブルクオーテーション" "でくくることで文字列リテラルとなります。 C#では任意の1文字を引用符・アポストロフィ' 'でくくることで文字リテラル(char型)となります。 VBでは二重引用符の後ろにサフィックスCを付けることで文字リテラルとなります。
var s = "Hello, world!"; // 文字列リテラル
var c = 'X'; // 文字リテラル
Dim s As String = "Hello, world!" ' 文字列リテラル
Dim c As Char = "X"C ' 文字リテラル
文字列中にヌル(NUL)・タブ(TAB)・ラインフィード(LF)・キャリッジリターン(CR)などの制御文字を記述する場合、C#ではバックスラッシュ\に続けて制御文字の記号を記述します。 VBではvbXXなどの定数や、ControlCharsクラスのフィールドを参照します。 文字リテラルを記述する場合も同様です。
C#では、バックスラッシュ自体をエスケープする場合には、\\のようにバックスラッシュを二つ続けて記述します。 また文字列リテラル中に二重引用符を含めたい場合は、\"のようにバックスラッシュを使ってエスケープします。
VBでは、また文字列リテラル中に二重引用符を含めたい場合は""のように二重引用符を二つ続けて記述します。
var nul = "NUL = \0";
var tab = "TAB = \t";
var cr = "CR = \r";
var lf = "LF = \n";
var bksl = "back slash = [\\]";
var dbqt = "double quotation = [\"]";
Dim nul As String = "NUL = " + vbNullChar
Dim tab As String = "TAB = " + vbTab
Dim cr As String = "CR = " + vbCr
Dim lf As String = "LF = " + vbLf
Dim bksl As String = "back slash = [\]"
Dim dbqt As String = "double quotation = [""]"
Dim nul As String = "NUL = " + ControlChars.NullChar
Dim tab As String = "TAB = " + ControlChars.Tab
Dim cr As String = "CR = " + ControlChars.Cr
Dim lf As String = "LF = " + ControlChars.Lf
Dim bksl As String = "back slash = [\]"
Dim dbqt As String = "double quotation = [" + ControlChars.Quote + "]"
C#では、エスケープシーケンス\xnおよび\unnnnを使うことで文字のUnicodeコードポイントを16進数で指定してリテラルを記述できます。 \unnnnは常に4桁でコードポイントを指定する必要がありますが、\xnの場合桁数は可変です。 そのため、\xnに続けて数値を記述しようとする場合、意図しないエスケープとならないよう注意する必要があります。
using System;
class Sample {
static void Main()
{
Console.WriteLine("\x61"); // 0x61(U+0061) 'a' が表示される
Console.WriteLine("\x6100"); // 0x6011(U+6100) '愀' が表示される
Console.WriteLine("\x061"); // 0x61(U+0061) 'a' が表示される
Console.WriteLine("\x0061"); // 0x61(U+0061) 'a' が表示される
Console.WriteLine("\x006100"); // 0x61(U+0061) 'a' と '00'が表示される
Console.WriteLine();
Console.WriteLine("\u0061"); // 0x61(U+0061) 'a' が表示される
Console.WriteLine("\u6100"); // 0x6011(U+6100) '愀' が表示される
Console.WriteLine("\u006100"); // 0x61(U+0061) 'a' と '00'が表示される
}
}
a 愀 a a a00 a 愀 a00
VBには\xnや\unnnnのような文字列中でコードポイントを記述するエスケープシーケンスはありません。 代わりに、ChrW関数を使うことによりUnicodeコードポイントから文字を取得することができます。
Imports System
Class Sample
Shared Sub Main()
Console.WriteLine(ChrW(&H61)) ' "a" が表示される
End Sub
End Class
逐語的文字列リテラル
C#では通常の文字列リテラルのほかに、逐語的文字列リテラルで文字列リテラルを記述することができます。 @" "のように文字列リテラルの二重引用符の前にアットマーク@を前置することで逐語的文字列リテラルはとなり、逐語的文字列リテラル内では\nや\\などのエスケープシーケンスは無効化され、そのまま文字列化されます。
逐語的文字列リテラルを用いることにより、ファイルパスや正規表現などバックスラッシュ\を多用する文字列を見やすく記述することができます。 逐語的文字列リテラル内ではエスケープシーケンスは無効化されるため、二重引用符を記述する場合は""のように二つ重ねて記述します。
using System;
using System.Text.RegularExpressions;
class Sample {
static void Main()
{
// 通常の文字列リテラルと逐語的文字列リテラルの例
var s1 = "abc\n\"def\"\x67\x68\x69";
var s2 = @"abc\n""def""\x67\x68\x69";
Console.WriteLine(s1);
Console.WriteLine(s2);
Console.WriteLine();
// 通常の文字列リテラルと逐語的文字列リテラルでファイルパスを記述する例
var path1 = "C:\\Windows\\Microsoft.NET\\Framework";
var path2 = @"C:\Windows\Microsoft.NET\Framework";
Console.WriteLine(path1);
Console.WriteLine(path2);
Console.WriteLine();
// 通常の文字列リテラルと逐語的文字列リテラルで正規表現を記述する例
var regex1 = new Regex("\\d{1,3}(\\.\\d{1,3}){3}(/\\d{1,2})?");
var regex2 = new Regex(@"\d{1,3}(\.\d{1,3}){3}(/\d{1,2})?");
Console.WriteLine(regex1);
Console.WriteLine(regex2);
Console.WriteLine();
}
}
abc
"def"ghi
abc\n"def"\x67\x68\x69
C:\Windows\Microsoft.NET\Framework
C:\Windows\Microsoft.NET\Framework
\d{1,3}(\.\d{1,3}){3}(/\d{1,2})?
\d{1,3}(\.\d{1,3}){3}(/\d{1,2})?
正規表現要素をエスケープした文字列で表現する、あるいはエスケープされている文字列から正規表現要素に変換するメソッドとして、Regex.Escape/Regex.Unescapeメソッドが用意されています。
PerlやJavaScript等の言語では/\d+/や/\.txt$/といった正規表現リテラルがサポートされていますが、C#およびVBでは正規表現リテラルは用意されておらず使用することはできません。 このような文字列をコード中に記述しても正規表現とは解釈されず、また正しくコンパイルされません。 正規表現を扱う方法については正規表現によるパターンマッチングと文字列操作を参照してください。
複数行の文字列リテラル
C#の逐語的文字列リテラルでは、複数行にわたる文字列を記述することもできます。 通常の文字列リテラルで複数行の文字列を記述する場合は途中に改行文字を挟む必要がありますが、逐語的文字列リテラルでは改行文字は不要です。
using System;
class Sample {
static void Main()
{
var s1 = @"line1
line2
line3";
var s2 = "line1\n" +
"line2\n" +
"line3";
Console.WriteLine(s1);
Console.WriteLine();
Console.WriteLine(s2);
Console.WriteLine();
}
}
line1 line2 line3 line1 line2 line3
逐語的文字列リテラル内の改行文字はソースファイルと同じ改行文字が使われます。 ソースファイルの改行文字がCRLFなら、逐語的文字列リテラル内の改行文字もCRLFになります。
VB.NETではVB14(Visual Basic 2015)より複数行の文字列リテラルを記述することができるようになっています。 C#の逐語的文字列リテラルとは異なり、@を前置する必要はありません。
Imports System
Class Sample
Shared Sub Main()
Dim s As String = "line1
line2
line3"
Console.WriteLine(s)
End Sub
End Class
line1 line2 line3
サフィックス
数値および文字列のリテラルにサフィックスを付けることで、リテラルの型を明示的に指定することができます。 また、VBではサフィックスの他にも型文字と呼ばれる記号を付けることでも型を指定することができます。 なお、以下の表中では明記していませんが、VBでもサフィックスを小文字で指定できます。
特にリテラルを指定しない場合、数値型では(基本的には)int/Integer、実数型ではdouble/Doubleとして扱われ、代入に際しては代入先の型に変換されます。
| .NET | C# | VB | ||||||
|---|---|---|---|---|---|---|---|---|
| 型 | 型 | サフィックス | リテラルの例 | 型 | サフィックス | 型文字 | リテラルの例 | |
| 整数型 | System.SByte | sbyte | - | - | SByte | - | - | - |
| System.Int16 | short | - | - | Short |
S
|
- |
1024S
|
|
| System.Int32 | int | - |
100000
|
Integer |
I
|
%
|
100000
100000I
100000%
|
|
| System.Int64 | long |
L/l
(数字 1(one)を混同する可能性があるため、l(small L)を使用するとコンパイル時に警告となる) |
200L
3000000000l
|
Long |
L
|
&
|
00L
3000000000&
|
|
| System.Byte | byte | - | - | Byte | - | - | - | |
| System.UInt16 | ushort | - | - | UShort |
US
|
- |
2048US
|
|
| System.UInt32 | uint |
u/U
|
12u
12U
|
UInteger |
UI
|
- |
12UI
|
|
| System.UInt64 | ulong |
ul/LUなど(大文字小文字・ UとLの順序は自由) |
200ul
3000000000Lu
|
ULong |
UL
|
- |
3000000000UL
|
|
| 実数型 | System.Single | float |
f/F
|
1.0f
1.0F
|
Single |
F
|
!
|
1.0F
1.0!
|
| System.Double | double |
d/D
|
3.14
3.14d
3.14D
|
Double |
R
|
#
|
3.14
3.14R
3.14#
|
|
| System.Decimal | decimal |
m/M
|
0.66666666m
0.66666666M
|
Decimal |
D
|
@
|
0.66666666D
0.66666666@
|
|
| 文字・文字列型 | System.Char | char | - |
'A'
|
Char |
C
|
- |
"A"C
|
| System.String | string | - |
"ABC"
|
String | - | - |
"ABC"
|
|
| 型 | 型 | サフィックス | リテラルの例 | 型 | サフィックス | 型文字 | リテラルの例 | |
| .NET | C# | VB | ||||||
数値リテラルでは、数字とサフィックスの間に桁区切り文字を入れることはできません。
using System;
class Sample {
static void Main()
{
var l = 100l; // long型の整数リテラル // warning CS0078: l' と 数字の '1' との混同を避けるため、'L' を使用してください。
var L = 100L; // long型の整数リテラル (小文字のlと同じだが、警告にはならない)
var u = 100u; // uint型の整数リテラル
var ul = 100uL; // ulong型の整数リテラル
var i = 100; // 型を明示しない実数リテラル(intの範囲内の数値のため、intとなる)
var n = 9223372036854775808; // 型を明示しない実数リテラル(ulongの範囲の数値のため、ulongとなる)
Console.WriteLine($"{l} ({l.GetType()})");
Console.WriteLine($"{L} ({L.GetType()})");
Console.WriteLine($"{u} ({u.GetType()})");
Console.WriteLine($"{ul} ({ul.GetType()})");
Console.WriteLine($"{i} ({i.GetType()})");
Console.WriteLine($"{n} ({n.GetType()})");
}
}
100 (System.Int64) 100 (System.Int64) 100 (System.UInt32) 100 (System.UInt64) 100 (System.Int32) 9223372036854775808 (System.UInt64)
Option Infer On
Imports System
Class Sample
Shared Sub Main()
Dim l = 100L ' Long型の整数リテラル
Dim ui = 100UI ' UInteger型の整数リテラル
Dim ul = 100UL ' ULong型の整数リテラル
Dim i = 100 ' 型を明示しない実数リテラル (Integer型となる)
Dim n = 9223372036854775808UL ' ULong型以外ではオーバーフローとなるのでサフィックスで型を明示する必要がある
Console.WriteLine($"{l} ({l.GetType()})")
Console.WriteLine($"{ui} ({ui.GetType()})")
Console.WriteLine($"{ul} ({ul.GetType()})")
Console.WriteLine($"{i} ({i.GetType()})")
Console.WriteLine($"{n} ({n.GetType()})")
End Sub
End Class
100 (System.Int64) 100 (System.UInt32) 100 (System.UInt64) 100 (System.Int32) 9223372036854775808 (System.UInt64)
16進数表記・8進数表記などのプレフィックス付きの整数リテラルを記述する場合でも、サフィックスを付けることで型を指定することができます。
using System;
class Sample {
static void Main()
{
// 10進数リテラルとサフィックス
Console.WriteLine("{0} {1}", 100, (100).GetType());
Console.WriteLine("{0} {1}", 100u, (100u).GetType());
Console.WriteLine("{0} {1}", 100L, (100L).GetType());
Console.WriteLine();
// 16進数リテラルとサフィックス
Console.WriteLine("{0} {1}", 0x100, (0x100).GetType());
Console.WriteLine("{0} {1}", 0x100u, (0x100u).GetType());
Console.WriteLine("{0} {1}", 0x100L, (0x100L).GetType());
Console.WriteLine();
// 2進数リテラルとサフィックス
Console.WriteLine("{0} {1}", 0b100, (0b100).GetType());
Console.WriteLine("{0} {1}", 0b100u, (0b100u).GetType());
Console.WriteLine("{0} {1}", 0b100L, (0b100L).GetType());
Console.WriteLine();
}
}
Imports System
Class Sample
Shared Sub Main()
' 10進数リテラルとサフィックス
Console.WriteLine("{0} {1}", 100, (100).GetType())
Console.WriteLine("{0} {1}", 100UI, (100UI).GetType())
Console.WriteLine("{0} {1}", 100L, (100L).GetType())
Console.WriteLine()
' 16進数リテラルとサフィックス
Console.WriteLine("{0} {1}", &H100, (&H100).GetType())
Console.WriteLine("{0} {1}", &H100UI, (&H100UI).GetType())
Console.WriteLine("{0} {1}", &H100L, (&H100L).GetType())
Console.WriteLine()
' 2進数リテラルとサフィックス
Console.WriteLine("{0} {1}", &B100, (&B100).GetType())
Console.WriteLine("{0} {1}", &B100UI, (&B100UI).GetType())
Console.WriteLine("{0} {1}", &B100L, (&B100L).GetType())
Console.WriteLine()
End Sub
End Class
100 System.Int32 100 System.UInt32 100 System.Int64 256 System.Int32 256 System.UInt32 256 System.Int64 4 System.Int32 4 System.UInt32 4 System.Int64
using System;
class Sample {
static void Main()
{
var f = 3.14f; // float型の実数リテラル
var d = 3.14d; // double型の実数リテラル
var m = 3.14m; // decimal型の実数リテラル
var n = 3.14; // 型を明示しない実数リテラル(double型となる)
Console.WriteLine($"{f} ({f.GetType()})");
Console.WriteLine($"{d} ({d.GetType()})");
Console.WriteLine($"{m} ({m.GetType()})");
Console.WriteLine($"{n} ({n.GetType()})");
}
}
Option Infer On
Imports System
Class Sample
Shared Sub Main()
Dim f = 3.14F ' Single型の実数リテラル
Dim r = 3.14R ' Double型の実数リテラル
Dim d = 3.14D ' Decimal型の実数リテラル
Dim n = 3.14 ' 型を明示しない実数リテラル(Double型となる)
Console.WriteLine($"{f} ({f.GetType()})")
Console.WriteLine($"{r} ({r.GetType()})")
Console.WriteLine($"{d} ({d.GetType()})")
Console.WriteLine($"{n} ({n.GetType()})")
End Sub
End Class
3.14 (System.Single) 3.14 (System.Double) 3.14 (System.Decimal) 3.14 (System.Double)
リテラルにおける暗黙的な型指定
C#のvarによる宣言では、サフィックスで型を明示しない場合、値の大きさに応じて型が暗黙的に選択されます。 例として、0x_7FFF_FFFF以下の値はint、0x_8000_0000以上の値はuint、0x_1_0000_0000以上の値はlongといったように、代入時にオーバーフローが起こらないような型が暗黙的に選択されます。
using System;
static class Sample {
static void Main()
{
// サフィックスによって型を明示しない場合、値の大きさに応じて適切な型が選ばれる
var i = 0x7FFFFFFF; // int型・System.Int32
var ui = 0x80000000; // uint型・System.UInt32
var l = 0x7FFFFFFF_FFFFFFFF; // long型・System.Int64
var ul = 0x80000000_00000000; // ulong型・System.UInt64
Console.WriteLine($"{nameof(i)} ({i.GetType()}) : value = {i}");
Console.WriteLine($"{nameof(ui)} ({ui.GetType()}) : value = {ui}");
Console.WriteLine($"{nameof(l)} ({l.GetType()}) : value = {l}");
Console.WriteLine($"{nameof(ul)} ({ul.GetType()}) : value = {ul}");
}
}
i (System.Int32) : value = 2147483647 ui (System.UInt32) : value = 2147483648 l (System.Int64) : value = 9223372036854775807 ul (System.UInt64) : value = 9223372036854775808