Last Update 2023/09/21
概要
後置演算子
単項演算子
ビット演算子
論理演算子
[ ] 配列の添え字
sample.cpp
#include <iostream>
int main()
{
// 配列の添え字
int a[3] = { 1, 2, 3 };
int b[3][3] = // 2次元配列
{
{ 11, 12, 13 },
{ 21, 22, 23 },
{ 31, 32, 33 }
};
int c[2][2][2] = // 3次元配列
{
{
{ 111, 112 },
{ 121, 122 },
},
{
{ 211, 212 },
{ 221, 222 }
}
};
std::cout << "a[1] = " << a[1] << std::endl;
std::cout << "a[2] = " << a[2] << std::endl;
std::cout << "*(a + 1) = " << *(a + 1) << std::endl; // 上記配列使用の記述と等価
std::cout << "*(a + 2) = " << *(a + 2) << std::endl; // 〃
std::cout << std::endl;
std::cout << "b[0][1] = " << b[0][1] << std::endl;
std::cout << "b[1][2] = " << b[1][2] << std::endl;
std::cout << "*(*(b + 0) + 1) = " << *(*(b + 0) + 1) << std::endl; // 上記配列使用の記述と等価
std::cout << "*(*(b + 1) + 2) = " << *(*(b + 1) + 2) << std::endl; // 〃
std::cout << std::endl;
std::cout << "c[0][0][1] = " << c[0][0][1] << std::endl;
std::cout << "c[1][1][0] = " << c[1][1][0] << std::endl;
std::cout << "*(*(*(c + 0) + 0) + 1) = " << *(*(*(c + 0) + 0) + 1) << std::endl; // 上記配列使用の記述と等価
std::cout << "*(*(*(c + 1) + 1) + 0) = " << *(*(*(c + 1) + 1) + 0) << std::endl; // 〃
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
a[1] = 2
a[2] = 3
*(a + 1) = 2
*(a + 2) = 3
b[0][1] = 12
b[1][2] = 23
*(*(b + 0) + 1) = 12
*(*(b + 1) + 2) = 23
c[0][0][1] = 112
c[1][1][0] = 221
*(*(*(c + 0) + 0) + 1) = 112
*(*(*(c + 1) + 1) + 0) = 221
( ) 関数呼び出し
sample.cpp
#include <iostream>
// 引数が空の関数
int sampfunc1() { return 1; }
// 引数を伴う関数
int sampfunc2(int i1, int i2)
{
return i1 + i2;
}
int main()
{
int n;
// 関数呼び出し
// 引数が空の関数呼び出し
std::cout << "sampfunc1() = " << sampfunc1() << std::endl;
// 引数を伴う関数呼び出し
n = sampfunc2(1, 2);
std::cout << "n = " << n << std::endl;
// 関数ポインタによる呼び出し
int (*fnp)(int, int); // 関数へのポインタの定義
fnp = sampfunc2; // ポインタへのsampfunc2のアドレスの代入
n = fnp(1, 2);
std::cout << "n = " << n << std::endl;
std::cout << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
sampfunc1() = 1
n = 3
n = 3
明示的な型キャスト(関数表記)
sample.cpp
#include <iostream>
int main()
{
// 明示的な型キャスト(関数表記)
char c = 'a';
int i = 0x62;
std::cout << std::uppercase << std::hex;
std::cout << c << std::endl; // 型キャストなし
std::cout << int(c) << std::endl; // int型に変換
std::cout << i << std::endl; // 型キャストなし
std::cout << char(i) << std::endl; // char型に変換
std::cout << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
a
61
62
b
クラスメンバへのアクセス
sample.cpp
#include <iostream>
class Samp_c
{
int n;
public:
Samp_c(int i) : n(i) { }
int g() { return n;}
};
struct Samp_s
{
int n;
};
int main()
{
// クラスメンバーのアクセス
Samp_c sc(1); // Samp_cのクラスオブジェクト sc
Samp_s ss;
Samp_s *pss = &ss; // Samp_sオブジェクトへのポインタ pss
// pssで参照されるオブジェクトメンバへの「->」演算子を使用したアクセス
pss->n = 2;
// scのオブジェクトメンバへの「.」演算子を使用したアクセス
std::cout << "sc.g() = " << sc.g() << std::endl;
std::cout << "(pss->n)++ = " << (pss->n)++ << std::endl;
// 上記の式を「.」演算子で書き換え
std::cout << "(*pss).n = " << (*pss).n << std::endl;
std::cout << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
a
61
62
b
後置++および--
sample.cpp
#include <iostream>
int main()
{
// 後置++および--
int i1 = 3, i2 = 3;
int j1 = 3, j2 = 3;
// 後置++
i1 = i1 + 1;
j1++;
std::cout << "(1-1) i1 = " << i1 << ", j1 = " << j1 << std::endl;
std::cout << "(1-2) i1 = " << i1 << ", j1++ = " << j1++ << std::endl;
std::cout << "(1-3) i1 = " << i1 << ", j1 = " << j1 << std::endl;
// 後置--
i2 = i2 - 1;
j2--;
std::cout << "(2-1) i2 = " << i2 << ", j2 = " << j2 << std::endl;
std::cout << "(2-2) i2 = " << i2 << ", j2-- = " << j2-- << std::endl;
std::cout << "(2-3) i2 = " << i2 << ", j2 = " << j2 << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
(1-1) i1 = 4, j1 = 4
(1-2) i1 = 4, j1++ = 4 <--- 出力時点では加算されていない
(1-3) i1 = 4, j1 = 5 <--- 上記コード実行後の加算を確認
(2-1) i2 = 2, j2 = 2
(2-2) i2 = 2, j2-- = 2 <--- 出力時点では減算されていない
(2-3) i2 = 2, j2 = 1 <--- 上記コード実行後の減算を確認
アドレス演算子 &、間接演算子 *
sample.cpp
#include <iostream>
int main()
{
// アドレス演算子 &、間接演算子 *
int i = 1;
// 変数iの値とアドレス(アドレス演算子 &)
std::cout << "i = " << i << " --- &i = " << &i << std::endl;
// ポインタにアドレスを代入
int *pi = &i;
// ポインタpiの値(アドレス)と参照するオブジェクト(間接演算子 *)
std::cout << "pi = " << pi << " --- *pi = " << *pi << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
i = 1 --- &i = 0x7fffafd09dd4
pi = 0x7fffafd09dd4 --- *pi = 1
論理否定演算子 !
sample.cpp
#include <iostream>
int main()
{
// 論理否定演算子 !
std::cout << "!0 = " << !0 << std::endl;
std::cout << "!1 = " << !1 << std::endl;
std::cout << "!!0 = " << !!0 << std::endl;
std::cout << "!!1 = " << !!1 << std::endl;
std::cout << "!!!0 = " << !!!0 << std::endl;
std::cout << "!!!1 = " << !!!1 << std::endl;
std::cout << "!(-1) = " << !(-1) << std::endl;
std::cout << "!2 = " << !2 << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
!0 = 1 <--- オペランドが0の場合は1
!1 = 0 <--- オペランドが1の場合は0
!!0 = 0 <--- !1と同じ
!!1 = 1 <--- !0と同じ
!!!0 = 1 <--- !!1と同じ
!!!1 = 0 <--- !!0と同じ
!(-1) = 0 <--- オペランドが0以外の場合は0
!2 = 0 <--- 〃
ビット否定演算子 ~
sample.cpp
#include <iostream>
#include <limits>
int main()
{
std::cout << std::uppercase << std::hex;
// ビット否定演算子 ~
std::cout << "~0x00000000 = " << ~0x00000000 << std::endl;
std::cout << "~0x00000001 = " << ~0x00000001 << std::endl;
std::cout << "~0x80000001 = " << ~0x80000001 << std::endl;
std::cout << "~std::numeric_limits<unsigned int>::max() = "
<< "~0x" << std::numeric_limits<unsigned int>::max()
<< " = " << ~std::numeric_limits<unsigned int>::max() << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
~0x00000000 = FFFFFFFF <--- 1111...1111
~0x00000001 = FFFFFFFE <--- 1111...1110
~0x80000001 = 7FFFFFFE <--- 0111...1110
~std::numeric_limits<unsigned int>::max() = ~0xFFFFFFFF = 0 <--- 0000...0000
前置++および--
sample.cpp
#include <iostream>
int main()
{
// 前置++および--
int i1 = 3, i2 = 3;
int j1 = 3, j2 = 3;
// 前置++
i1 = i1 + 1;
++j1;
std::cout << "(1-1) i1 = " << i1 << ", j1 = " << j1 << std::endl;
std::cout << "(1-2) i1 = " << i1 << ", ++j1 = " << ++j1 << std::endl;
std::cout << "(1-3) i1 = " << i1 << ", j1 = " << j1 << std::endl;
// 前置--
i2 = i2 - 1;
--j2;
std::cout << "(2-1) i2 = " << i2 << ", j2 = " << j2 << std::endl;
std::cout << "(2-2) i2 = " << i2 << ", --j2 = " << --j2 << std::endl;
std::cout << "(2-3) i2 = " << i2 << ", j2 = " << j2 << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
(1-1) i1 = 4, j1 = 4
(1-2) i1 = 4, ++j1 = 5 <--- printf関数呼び出し時点で加算完了
(1-3) i1 = 4, j1 = 5 <--- 上記コード実行後、値の変化なし
(2-1) i2 = 2, j2 = 2
(2-2) i2 = 2, --j2 = 1 <--- printf関数呼び出し時点で減算完了
(2-3) i2 = 2, j2 = 1 <--- 上記コード実行後、値の変化なし
sizeof演算子
sample.cpp
#include <iostream>
class Samp_c
{
int n;
public:
Samp_c(int i) : n(i) { }
int g() { return n;}
};
struct Samp_s
{
int i;
long int l;
char buf[16];
};
int main()
{
int a[2][2][2] = // 3次元配列
{
{
{ 111, 112 },
{ 121, 122 },
},
{
{ 211, 212 },
{ 221, 222 }
}
};
Samp_c sc(1);
Samp_s ss;
Samp_s *pss = &ss;
// sizeof演算子
std::cout << "sizeof(char) = " << sizeof(char) << std::endl;
std::cout << "sizeof(signed char) = " << sizeof(signed char) << std::endl;
std::cout << "sizeof(unsigned char) = " << sizeof(unsigned char) << std::endl;
std::cout << "sizeof(wchar_t) = " << sizeof(wchar_t) << std::endl;
std::cout << "sizeof(char16_t) = " << sizeof(char16_t) << std::endl;
std::cout << "sizeof(char32_t) = " << sizeof(char32_t) << std::endl;
std::cout << "sizeof(bool) = " << sizeof(bool) << std::endl;
std::cout << "sizeof(short int) = " << sizeof(short int) << std::endl;
std::cout << "sizeof(int) = " << sizeof(int) << std::endl;
std::cout << "sizeof(long int) = " << sizeof(long int) << std::endl;
std::cout << "sizeof(long long int) = " << sizeof(long long int) << std::endl;
std::cout << "sizeof(unsigned short int) = " << sizeof(unsigned short int) << std::endl;
std::cout << "sizeof(unsigned int) = " << sizeof(unsigned int) << std::endl;
std::cout << "sizeof(unsigned long int) = " << sizeof(unsigned long int) << std::endl;
std::cout << "sizeof(unsigned long long int) = " << sizeof(unsigned long long int) << std::endl;
std::cout << "sizeof(float) = " << sizeof(float) << std::endl;
std::cout << "sizeof(double) = " << sizeof(double) << std::endl;
std::cout << "sizeof(long double) = " << sizeof(long double) << std::endl;
std::cout << "sizeof a = " << sizeof a << std::endl;
std::cout << "sizeof(Samp_c) = " << sizeof(Samp_c) << std::endl;
std::cout << "sizeof sc = " << sizeof sc << std::endl;
std::cout << "sizeof(Samp_s) = " << sizeof(Samp_s) << std::endl;
std::cout << "sizeof ss = " << sizeof ss << std::endl;
std::cout << "sizeof pss = " << sizeof pss << std::endl;
std::cout << "sizeof *pss = " << sizeof *pss << std::endl;
std::cout << "sizeof ss.i = " << sizeof ss.i << std::endl;
std::cout << "sizeof ss.l = " << sizeof ss.l << std::endl;
std::cout << "sizeof ss.buf = " << sizeof ss.buf << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
sizeof(char) = 1
sizeof(signed char) = 1
sizeof(unsigned char) = 1
sizeof(wchar_t) = 4
sizeof(char16_t) = 2
sizeof(char32_t) = 4
sizeof(bool) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(unsigned short int) = 2
sizeof(unsigned int) = 4
sizeof(unsigned long int) = 8
sizeof(unsigned long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof a = 32
sizeof(Samp_c) = 4
sizeof sc = 4
sizeof(Samp_s) = 32
sizeof ss = 32
sizeof pss = 8
sizeof *pss = 32
sizeof ss.i = 4
sizeof ss.l = 8
sizeof ss.buf = 16
alignof演算子
sample.cpp
#include <iostream>
class Samp_c
{
int n;
public:
Samp_c(int i) : n(i) { }
int g() { return n;}
};
struct Samp_s
{
int i;
long int l;
char buf[16];
};
int main()
{
int a[2][2][2] = // 3次元配列
{
{
{ 111, 112 },
{ 121, 122 },
},
{
{ 211, 212 },
{ 221, 222 }
}
};
Samp_c sc(1);
Samp_s ss;
Samp_s *pss = &ss;
// alignof演算子
std::cout << "alignof(char) = " << alignof(char) << std::endl;
std::cout << "alignof(signed char) = " << alignof(signed char) << std::endl;
std::cout << "alignof(unsigned char) = " << alignof(unsigned char) << std::endl;
std::cout << "alignof(wchar_t) = " << alignof(wchar_t) << std::endl;
std::cout << "alignof(char16_t) = " << alignof(char16_t) << std::endl;
std::cout << "alignof(char32_t) = " << alignof(char32_t) << std::endl;
std::cout << "alignof(bool) = " << alignof(bool) << std::endl;
std::cout << "alignof(short int) = " << alignof(short int) << std::endl;
std::cout << "alignof(int) = " << alignof(int) << std::endl;
std::cout << "alignof(long int) = " << alignof(long int) << std::endl;
std::cout << "alignof(long long int) = " << alignof(long long int) << std::endl;
std::cout << "alignof(unsigned short int) = " << alignof(unsigned short int) << std::endl;
std::cout << "alignof(unsigned int) = " << alignof(unsigned int) << std::endl;
std::cout << "alignof(unsigned long int) = " << alignof(unsigned long int) << std::endl;
std::cout << "alignof(unsigned long long int) = " << alignof(unsigned long long int) << std::endl;
std::cout << "alignof(float) = " << alignof(float) << std::endl;
std::cout << "alignof(double) = " << alignof(double) << std::endl;
std::cout << "alignof(long double) = " << alignof(long double) << std::endl;
std::cout << "alignof(a) = " << alignof(a) << std::endl;
std::cout << "alignof(Samp_c) = " << alignof(Samp_c) << std::endl;
std::cout << "alignof(sc) = " << alignof(sc) << std::endl;
std::cout << "alignof(Samp_s) = " << alignof(Samp_s) << std::endl;
std::cout << "alignof(ss) = " << alignof(ss) << std::endl;
std::cout << "alignof(pss) = " << alignof(pss) << std::endl;
std::cout << "alignof(*pss) = " << alignof(*pss) << std::endl;
std::cout << "alignof(ss.i) = " << alignof(ss.i) << std::endl;
std::cout << "alignof(ss.l) = " << alignof(ss.l) << std::endl;
std::cout << "alignof(ss.buf) = " << alignof(ss.buf) << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
alignof(char) = 1
alignof(signed char) = 1
alignof(unsigned char) = 1
alignof(wchar_t) = 4
alignof(char16_t) = 2
alignof(char32_t) = 4
alignof(bool) = 1
alignof(short int) = 2
alignof(int) = 4
alignof(long int) = 8
alignof(long long int) = 8
alignof(unsigned short int) = 2
alignof(unsigned int) = 4
alignof(unsigned long int) = 8
alignof(unsigned long long int) = 8
alignof(float) = 4
alignof(double) = 8
alignof(long double) = 16
alignof(a) = 4
alignof(Samp_c) = 4
alignof(sc) = 4
alignof(Samp_s) = 8
alignof(ss) = 8
alignof(pss) = 8
alignof(*pss) = 8
alignof(ss.i) = 4
alignof(ss.l) = 8
alignof(ss.buf) = 1
乗除演算子 * / %
sample.cpp
#include <iostream>
int main()
{
std::cout << "乗除演算子 * / %" << std::endl;
std::cout << "( )内は「sizeof(当該演算子を使用した式)」で返されたバイト数" << std::endl;
std::cout << std::endl;
// 乗法演算子
std::cout << "整数型 * 整数型 : 4 * 3 = " << 4 * 3
<< " (" << sizeof(4 * 3) << ")" << std::endl;
std::cout << "浮動小数点型 * 浮動小数点型 : 4.0 * 3.0 = " << 4.0 * 3.0
<< " (" << sizeof(4.0 * 3.0) << ")" << std::endl;
std::cout << std::endl;
// 除法演算子
std::cout << "整数型 / 整数型 : 4 / 3 = " << 4 / 3
<< " (" << sizeof(4 / 3) << ")" << std::endl;
std::cout << "浮動小数点型 / 整数型 : 4.0 / 3 = " << 4.0 / 3
<< " (" << sizeof(4.0 / 3) << ")" << std::endl;
std::cout << "浮動小数点型 / 浮動小数点型 : 4.0 / 3.0 = " << 4.0 / 3.0
<< " (" << sizeof(4.0 / 3.0) << ")" << std::endl;
std::cout << std::endl;
// 剰余演算子
std::cout << "整数型 % 整数型 : 4 % 3 = " << 4 % 3
<< " (" << sizeof(4 % 3) << ")" << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
乗除演算子 * / %
( )内は「sizeof(当該演算子を使用した式)」で返されたバイト数
整数型 * 整数型 : 4 * 3 = 12 (4)
浮動小数点型 * 浮動小数点型 : 4.0 * 3.0 = 12 (8)
整数型 / 整数型 : 4 / 3 = 1 (4)
浮動小数点型 / 整数型 : 4.0 / 3 = 1.33333 (8) <--- 算術型変換により整数型は浮動小数点型に変換後演算
浮動小数点型 / 浮動小数点型 : 4.0 / 3.0 = 1.33333 (8)
整数型 % 整数型 : 4 % 3 = 1 (4)
加減演算子 + -
sample.cpp
#include <iostream>
int main()
{
std::cout << "加減演算子 + -" << std::endl;
std::cout << "末尾の( )内は「sizeof(当該演算子を使用した式)」で返されたバイト数" << std::endl;
std::cout << std::endl;
char c[10] = "abcdefg";
char *p = &c[3];
// 加法演算子
std::cout << "整数型 + 整数型 : 4 + 3 = " << 4 + 3
<< " (" << sizeof(4 + 3) << ")" << std::endl;
std::cout << "浮動小数点型 + 整数型 : 4.5 + 3 = " << 4.5 + 3
<< " (" << sizeof(4.5 + 3) << ")" << std::endl;
std::cout << "浮動小数点型 + 浮動小数点型 : 4.5 + 3.0 = " << 4.5 + 3.0
<< " (" << sizeof(4.5 + 3.0) << ")" << std::endl;
std::cout << "ポインタ型 + 整数型 : p('" << *p << "') + 2 ---> " << *(p + 2) << std::endl;
std::cout << std::endl;
// 減法演算子
std::cout << "整数型 - 整数型 : 4 - 3 = " << 4 - 3
<< " (" << sizeof(4 - 3) << ")" << std::endl;
std::cout << "浮動小数点型 - 整数型 : 4.5 - 3 = " << 4.5 - 3
<< " (" << sizeof(4.5 - 3) << ")" << std::endl;
std::cout << "浮動小数点型 - 浮動小数点型 : 4.5 - 3.5 = " << 4.5 - 3.5
<< " (" << sizeof(4.5 - 3.5) << ")" << std::endl;
std::cout << "ポインタ型 - 整数型 : p('" << *p << "') - 2 ---> " << *(p - 2) << std::endl;
std::cout << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
加減演算子 + -
末尾の( )内は「sizeof(当該演算子を使用した式)」で返されたバイト数
整数型 + 整数型 : 4 + 3 = 7 (4)
浮動小数点型 + 整数型 : 4.5 + 3 = 7.5 (8)
浮動小数点型 + 浮動小数点型 : 4.5 + 3.0 = 7.5 (8)
ポインタ型 + 整数型 : p('d') + 2 ---> f
整数型 - 整数型 : 4 - 3 = 1 (4)
浮動小数点型 - 整数型 : 4.5 - 3 = 1.5 (8)
浮動小数点型 - 浮動小数点型 : 4.5 - 3.5 = 1 (8)
ポインタ型 - 整数型 : p('d') - 2 ---> b
シフト演算子 << >>
sample.cpp
#include <iostream>
#include <iomanip>
// 2進数出力用関数
void putbd(unsigned int n)
{
for (unsigned int i=0; i<4*8; i++)
{
std::cout << static_cast<char>('0' + (n & ((1u << (4*8-1)) >> i) ? 1 : 0));
}
}
int main()
{
std::cout << "シフト演算子 << >>" << std::endl;
std::cout << std::endl;
unsigned int x = 1 << (4*8-1);
// 左シフト
std::cout << "左シフト初期値整数 1" << std::endl;
for (int i=0; i<4*8; i++)
{
std::cout << "1 << "
<< std::setw(2) << i << " "
<< std::setw(11) << (1 << i) << " ";
putbd(1 << i);
std::cout << std::endl;
}
std::cout << std::endl;
// 右シフト(符号無し整数)
std::cout << "右シフト初期値整数 x = " << x << "(unsigned int)" << std::endl;
for (int i=0; i<4*8; i++)
{
std::cout << "x >> "
<< std::setw(2) << i << " "
<< std::setw(11) << (x >> i) << " ";
putbd(x >> i);
std::cout << std::endl;
}
std::cout << std::endl;
// 右シフト(符号付き整数)
std::cout << "右シフト初期値整数 x = "
<< static_cast<int>(x) << "(int)" << std::endl;
for (int i=0; i<4*8; i++)
{
std::cout << "(int)x >> "
<< std::setw(2) << i << " "
<< std::setw(11) << (static_cast<int>(x) >> i) << " ";
putbd(static_cast<int>(x) >> i);
std::cout << std::endl;
}
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
シフト演算子 << >>
左シフト初期値整数 1
1 << 0 1 00000000000000000000000000000001
1 << 1 2 00000000000000000000000000000010
1 << 2 4 00000000000000000000000000000100
1 << 3 8 00000000000000000000000000001000
1 << 4 16 00000000000000000000000000010000
1 << 5 32 00000000000000000000000000100000
1 << 6 64 00000000000000000000000001000000
1 << 7 128 00000000000000000000000010000000
1 << 8 256 00000000000000000000000100000000
1 << 9 512 00000000000000000000001000000000
1 << 10 1024 00000000000000000000010000000000
1 << 11 2048 00000000000000000000100000000000
1 << 12 4096 00000000000000000001000000000000
1 << 13 8192 00000000000000000010000000000000
1 << 14 16384 00000000000000000100000000000000
1 << 15 32768 00000000000000001000000000000000
1 << 16 65536 00000000000000010000000000000000
1 << 17 131072 00000000000000100000000000000000
1 << 18 262144 00000000000001000000000000000000
1 << 19 524288 00000000000010000000000000000000
1 << 20 1048576 00000000000100000000000000000000
1 << 21 2097152 00000000001000000000000000000000
1 << 22 4194304 00000000010000000000000000000000
1 << 23 8388608 00000000100000000000000000000000
1 << 24 16777216 00000001000000000000000000000000
1 << 25 33554432 00000010000000000000000000000000
1 << 26 67108864 00000100000000000000000000000000
1 << 27 134217728 00001000000000000000000000000000
1 << 28 268435456 00010000000000000000000000000000
1 << 29 536870912 00100000000000000000000000000000
1 << 30 1073741824 01000000000000000000000000000000
1 << 31 -2147483648 10000000000000000000000000000000
右シフト初期値整数 x = 2147483648(unsigned int)
x >> 0 2147483648 10000000000000000000000000000000
x >> 1 1073741824 01000000000000000000000000000000
x >> 2 536870912 00100000000000000000000000000000
x >> 3 268435456 00010000000000000000000000000000
x >> 4 134217728 00001000000000000000000000000000
x >> 5 67108864 00000100000000000000000000000000
x >> 6 33554432 00000010000000000000000000000000
x >> 7 16777216 00000001000000000000000000000000
x >> 8 8388608 00000000100000000000000000000000
x >> 9 4194304 00000000010000000000000000000000
x >> 10 2097152 00000000001000000000000000000000
x >> 11 1048576 00000000000100000000000000000000
x >> 12 524288 00000000000010000000000000000000
x >> 13 262144 00000000000001000000000000000000
x >> 14 131072 00000000000000100000000000000000
x >> 15 65536 00000000000000010000000000000000
x >> 16 32768 00000000000000001000000000000000
x >> 17 16384 00000000000000000100000000000000
x >> 18 8192 00000000000000000010000000000000
x >> 19 4096 00000000000000000001000000000000
x >> 20 2048 00000000000000000000100000000000
x >> 21 1024 00000000000000000000010000000000
x >> 22 512 00000000000000000000001000000000
x >> 23 256 00000000000000000000000100000000
x >> 24 128 00000000000000000000000010000000
x >> 25 64 00000000000000000000000001000000
x >> 26 32 00000000000000000000000000100000
x >> 27 16 00000000000000000000000000010000
x >> 28 8 00000000000000000000000000001000
x >> 29 4 00000000000000000000000000000100
x >> 30 2 00000000000000000000000000000010
x >> 31 1 00000000000000000000000000000001
右シフト初期値整数 x = -2147483648(int)
(int)x >> 0 -2147483648 10000000000000000000000000000000
(int)x >> 1 -1073741824 11000000000000000000000000000000
(int)x >> 2 -536870912 11100000000000000000000000000000
(int)x >> 3 -268435456 11110000000000000000000000000000
(int)x >> 4 -134217728 11111000000000000000000000000000
(int)x >> 5 -67108864 11111100000000000000000000000000
(int)x >> 6 -33554432 11111110000000000000000000000000
(int)x >> 7 -16777216 11111111000000000000000000000000
(int)x >> 8 -8388608 11111111100000000000000000000000
(int)x >> 9 -4194304 11111111110000000000000000000000
(int)x >> 10 -2097152 11111111111000000000000000000000
(int)x >> 11 -1048576 11111111111100000000000000000000
(int)x >> 12 -524288 11111111111110000000000000000000
(int)x >> 13 -262144 11111111111111000000000000000000
(int)x >> 14 -131072 11111111111111100000000000000000
(int)x >> 15 -65536 11111111111111110000000000000000
(int)x >> 16 -32768 11111111111111111000000000000000
(int)x >> 17 -16384 11111111111111111100000000000000
(int)x >> 18 -8192 11111111111111111110000000000000
(int)x >> 19 -4096 11111111111111111111000000000000
(int)x >> 20 -2048 11111111111111111111100000000000
(int)x >> 21 -1024 11111111111111111111110000000000
(int)x >> 22 -512 11111111111111111111111000000000
(int)x >> 23 -256 11111111111111111111111100000000
(int)x >> 24 -128 11111111111111111111111110000000
(int)x >> 25 -64 11111111111111111111111111000000
(int)x >> 26 -32 11111111111111111111111111100000
(int)x >> 27 -16 11111111111111111111111111110000
(int)x >> 28 -8 11111111111111111111111111111000
(int)x >> 29 -4 11111111111111111111111111111100
(int)x >> 30 -2 11111111111111111111111111111110
(int)x >> 31 -1 11111111111111111111111111111111
関係演算子 < > <= >=
sample.cpp
#include <iostream>
int main()
{
int i1 = 1;
int i2 = 2;
int i3 = 1;
double d1 = 1.0;
double d2 = 2.0;
double d3 = 1.0;
int n[2] = {1, 2};
int *p1 = &n[0];
int *p2 = &n[1];
int *p3 = &n[0];
std::cout << "関係演算子 真:1 偽:0" << std::endl;
std::cout << std::endl;
std::cout << "1 (int) < 2 (int) --- i1 < i2 --> " << (i1 < i2) << std::endl;
std::cout << "1 (int) < 1 (int) --- i1 < i3 --> " << (i1 < i3) << std::endl;
std::cout << "1.0 (double) < 2.0 (double) --- d1 < d2 --> " << (d1 < d2) << std::endl;
std::cout << "1.0 (double) < 1.0 (double) --- d1 < d3 --> " << (d1 < d3) << std::endl;
std::cout << "1 (int) < 2.0 (double) --- i1 < d2 --> " << (i1 < d2) << std::endl;
std::cout << "1 (int) < 1.0 (double) --- i1 < d1 --> " << (i1 < d3) << std::endl;
std::cout << "&n[0] (int *) < &n[1] (int *) --- p1 < p2 --> " << (p1 < p2) << std::endl;
std::cout << "&n[0] (int *) < &n[0] (int *) --- p1 < p3 --> " << (p1 < p3) << std::endl;
std::cout << std::endl;
std::cout << "2 (int) > 1 (int) --- i2 > i1 --> " << (i2 > i1) << std::endl;
std::cout << "1 (int) > 1 (int) --- i1 > i3 --> " << (i1 > i3) << std::endl;
std::cout << "2.0 (double) > 1.0 (double) --- d2 > d1 --> " << (d2 > d1) << std::endl;
std::cout << "1.0 (double) > 1.0 (double) --- d3 > d1 --> " << (d3 > d1) << std::endl;
std::cout << "2 (int) > 1.0 (double) --- i2 > d1 --> " << (i2 > d1) << std::endl;
std::cout << "1 (int) > 1.0 (double) --- i1 > d1 --> " << (i1 > d1) << std::endl;
std::cout << "&n[1] (int *) > &n[0] (int *) --- p2 > p1 --> " << (p2 > p1) << std::endl;
std::cout << "&n[0] (int *) > &n[0] (int *) --- p1 > p3 --> " << (p1 > p3) << std::endl;
std::cout << std::endl;
std::cout << "1 (int) <= 2 (int) --- i1 <= i2 --> " << (i1 <= i2) << std::endl;
std::cout << "1 (int) <= 1 (int) --- i1 <= i3 --> " << (i1 <= i3) << std::endl;
std::cout << "1.0 (double) <= 2.0 (double) --- d1 <= d2 --> " << (d1 <= d2) << std::endl;
std::cout << "1.0 (double) <= 1.0 (double) --- d1 <= d3 --> " << (d1 <= d3) << std::endl;
std::cout << "1 (int) <= 2.0 (double) --- i1 <= d2 --> " << (i1 <= d2) << std::endl;
std::cout << "1 (int) <= 1.0 (double) --- i1 <= d1 --> " << (i1 <= d3) << std::endl;
std::cout << "&n[0] (int *) <= &n[1] (int *) --- p1 <= p2 --> " << (p1 <= p2) << std::endl;
std::cout << "&n[0] (int *) <= &n[0] (int *) --- p1 <= p3 --> " << (p1 <= p3) << std::endl;
std::cout << std::endl;
std::cout << "2 (int) >= 1 (int) --- i2 >= i1 --> " << (i2 >= i1) << std::endl;
std::cout << "1 (int) >= 1 (int) --- i1 >= i3 --> " << (i1 >= i3) << std::endl;
std::cout << "2.0 (double) >= 1.0 (double) --- d2 >= d1 --> " << (d2 >= d1) << std::endl;
std::cout << "1.0 (double) >= 1.0 (double) --- d3 >= d1 --> " << (d3 >= d1) << std::endl;
std::cout << "2 (int) >= 1.0 (double) --- i2 >= d1 --> " << (i2 >= d1) << std::endl;
std::cout << "1 (int) >= 1.0 (double) --- i1 >= d1 --> " << (i2 >= d1) << std::endl;
std::cout << "&n[1] (int *) >= &n[0] (int *) --- p2 >= p1 --> " << (p1 <= p2) << std::endl;
std::cout << "&n[0] (int *) >= &n[0] (int *) --- p1 >= p3 --> " << (p1 <= p3) << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
関係演算子 真:1 偽:0
1 (int) < 2 (int) --- i1 < i2 --> 1
1 (int) < 1 (int) --- i1 < i3 --> 0
1.0 (double) < 2.0 (double) --- d1 < d2 --> 1
1.0 (double) < 1.0 (double) --- d1 < d3 --> 0
1 (int) < 2.0 (double) --- i1 < d2 --> 1
1 (int) < 1.0 (double) --- i1 < d1 --> 0
&n[0] (int *) < &n[1] (int *) --- p1 < p2 --> 1
&n[0] (int *) < &n[0] (int *) --- p1 < p3 --> 0
2 (int) > 1 (int) --- i2 > i1 --> 1
1 (int) > 1 (int) --- i1 > i3 --> 0
2.0 (double) > 1.0 (double) --- d2 > d1 --> 1
1.0 (double) > 1.0 (double) --- d3 > d1 --> 0
2 (int) > 1.0 (double) --- i2 > d1 --> 1
1 (int) > 1.0 (double) --- i1 > d1 --> 0
&n[1] (int *) > &n[0] (int *) --- p2 > p1 --> 1
&n[0] (int *) > &n[0] (int *) --- p1 > p3 --> 0
1 (int) <= 2 (int) --- i1 <= i2 --> 1
1 (int) <= 1 (int) --- i1 <= i3 --> 1
1.0 (double) <= 2.0 (double) --- d1 <= d2 --> 1
1.0 (double) <= 1.0 (double) --- d1 <= d3 --> 1
1 (int) <= 2.0 (double) --- i1 <= d2 --> 1
1 (int) <= 1.0 (double) --- i1 <= d1 --> 1
&n[0] (int *) <= &n[1] (int *) --- p1 <= p2 --> 1
&n[0] (int *) <= &n[0] (int *) --- p1 <= p3 --> 1
2 (int) >= 1 (int) --- i2 >= i1 --> 1
1 (int) >= 1 (int) --- i1 >= i3 --> 1
2.0 (double) >= 1.0 (double) --- d2 >= d1 --> 1
1.0 (double) >= 1.0 (double) --- d3 >= d1 --> 1
2 (int) >= 1.0 (double) --- i2 >= d1 --> 1
1 (int) >= 1.0 (double) --- i1 >= d1 --> 1
&n[1] (int *) >= &n[0] (int *) --- p2 >= p1 --> 1
&n[0] (int *) >= &n[0] (int *) --- p1 >= p3 --> 1
等価演算子 == !=
sample.cpp
#include <iostream>
int main()
{
int i1 = 1;
int i2 = 2;
int i3 = 1;
double d1 = 1.0;
double d2 = 2.0;
double d3 = 1.0;
int n[2] = {1, 2};
int *p1 = &n[0];
int *p2 = &n[1];
int *p3 = &n[0];
int *p4 = nullptr;
std::cout << "等価演算子 真:1 偽:0" << std::endl;
std::cout << std::endl;
std::cout << "1 (int) == 2 (int) --- i1 == i2 --> " << (i1 == i2) << std::endl;
std::cout << "1 (int) == 1 (int) --- i1 == i3 --> " << (i1 == i3) << std::endl;
std::cout << "1.0 (double) == 2.0 (double) --- d1 == d2 --> " << (d1 == d2) << std::endl;
std::cout << "1.0 (double) == 1.0 (double) --- d1 == d3 --> " << (d1 == d3) << std::endl;
std::cout << "1 (int) == 2.0 (double) --- i1 == d2 --> " << (i1 == d2) << std::endl;
std::cout << "1 (int) == 1.0 (double) --- i1 == d1 --> " << (i1 == d3) << std::endl;
std::cout << "&n[0] (int *) == &n[1] (int *) --- p1 == p2 --> " << (p1 == p2) << std::endl;
std::cout << "&n[0] (int *) == &n[0] (int *) --- p1 == p3 --> " << (p1 == p3) << std::endl;
std::cout << "&n[0] (int *) == nullptr --- p1 == nullptr --> " << (p1 == nullptr) << std::endl;
std::cout << "nullptr == nullptr --- p4 == nullptr --> " << (p4 == nullptr) << std::endl;
std::cout << std::endl;
std::cout << "1 (int) != 2 (int) --- i1 != i2 --> " << (i1 != i2) << std::endl;
std::cout << "1 (int) != 1 (int) --- i1 != i3 --> " << (i1 != i3) << std::endl;
std::cout << "1.0 (double) != 2.0 (double) --- d1 != d2 --> " << (d1 != d2) << std::endl;
std::cout << "1.0 (double) != 1.0 (double) --- d1 != d3 --> " << (d1 != d3) << std::endl;
std::cout << "1 (int) != 2.0 (double) --- i1 != d2 --> " << (i1 != d2) << std::endl;
std::cout << "1 (int) != 1.0 (double) --- i1 != d1 --> " << (i1 != d3) << std::endl;
std::cout << "&n[0] (int *) != &n[1] (int *) --- p1 != p2 --> " << (p1 != p2) << std::endl;
std::cout << "&n[0] (int *) != &n[0] (int *) --- p1 != p3 --> " << (p1 != p3) << std::endl;
std::cout << "&n[0] (int *) != nullptr --- p1 != nullptr --> " << (p1 != nullptr) << std::endl;
std::cout << "nullptr != nullptr --- p4 != nullptr --> " << (p4 != nullptr) << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
等価演算子 真:1 偽:0
1 (int) == 2 (int) --- i1 == i2 --> 0
1 (int) == 1 (int) --- i1 == i3 --> 1
1.0 (double) == 2.0 (double) --- d1 == d2 --> 0
1.0 (double) == 1.0 (double) --- d1 == d3 --> 1
1 (int) == 2.0 (double) --- i1 == d2 --> 0
1 (int) == 1.0 (double) --- i1 == d1 --> 1
&n[0] (int *) == &n[1] (int *) --- p1 == p2 --> 0
&n[0] (int *) == &n[0] (int *) --- p1 == p3 --> 1
&n[0] (int *) == nullptr --- p1 == nullptr --> 0
nullptr == nullptr --- p4 == nullptr --> 1
1 (int) != 2 (int) --- i1 != i2 --> 1
1 (int) != 1 (int) --- i1 != i3 --> 0
1.0 (double) != 2.0 (double) --- d1 != d2 --> 1
1.0 (double) != 1.0 (double) --- d1 != d3 --> 0
1 (int) != 2.0 (double) --- i1 != d2 --> 1
1 (int) != 1.0 (double) --- i1 != d1 --> 0
&n[0] (int *) != &n[1] (int *) --- p1 != p2 --> 1
&n[0] (int *) != &n[0] (int *) --- p1 != p3 --> 0
&n[0] (int *) != nullptr --- p1 != nullptr --> 1
nullptr != nullptr --- p4 != nullptr --> 0
ビット単位のAND演算子 &
sample.cpp
#include <iostream>
#include <iomanip>
int main()
{
std::cout << "ビット単位のAND演算子 &" << std::endl;
std::cout << std::endl;
std::cout << "0 & 0 = " << (0 & 0) << std::endl;
std::cout << "0 & 1 = " << (0 & 1) << std::endl;
std::cout << "1 & 0 = " << (1 & 0) << std::endl;
std::cout << "1 & 1 = " << (1 & 1) << std::endl;
std::cout << std::endl;
std::cout << std::uppercase << std::hex;
std::cout << "0x11 & 0x22 = 0x"
<< std::setw(2) << std::setfill('0') << (0x11 & 0x22)
<< std::endl;
std::cout << "00010001" << std::endl;
std::cout << "00100010" << std::endl;
std::cout << "--------" << std::endl;
std::cout << "00000000" << std::endl;
std::cout << std::endl;
std::cout << "0x11 & 0x33 = 0x"
<< std::setw(2) << std::setfill('0') << (0x11 & 0x33)
<< std::endl;
std::cout << "00010001" << std::endl;
std::cout << "00110011" << std::endl;
std::cout << "--------" << std::endl;
std::cout << "00010001" << std::endl;
std::cout << std::endl;
std::cout << "0x71 & 0x5F = 0x"
<< std::setw(2) << std::setfill('0') << (0x71 & 0x5F)
<< std::endl;
std::cout << "01110001" << std::endl;
std::cout << "01011111" << std::endl;
std::cout << "--------" << std::endl;
std::cout << "01010001" << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
ビット単位のAND演算子 &
0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1
0x11 & 0x22 = 0x00
00010001
00100010
--------
00000000
0x11 & 0x33 = 0x11
00010001
00110011
--------
00010001
0x71 & 0x5F = 0x51
01110001
01011111
--------
01010001
ビット単位のXOR演算子 ^
sample.cpp
#include <iostream>
#include <iomanip>
int main()
{
std::cout << "ビット単位のXOR演算子 ^" << std::endl;
std::cout << std::endl;
std::cout << "0 ^ 0 = " << (0 ^ 0) << std::endl;
std::cout << "0 ^ 1 = " << (0 ^ 1) << std::endl;
std::cout << "1 ^ 0 = " << (1 ^ 0) << std::endl;
std::cout << "1 ^ 1 = " << (1 ^ 1) << std::endl;
std::cout << std::endl;
std::cout << std::uppercase << std::hex;
std::cout << "0x11 ^ 0x22 = 0x"
<< std::setw(2) << std::setfill('0') << (0x11 ^ 0x22)
<< std::endl;
std::cout << "00010001" << std::endl;
std::cout << "00100010" << std::endl;
std::cout << "--------" << std::endl;
std::cout << "00110011" << std::endl;
std::cout << std::endl;
std::cout << "0x11 ^ 0x33 = 0x"
<< std::setw(2) << std::setfill('0') << (0x11 ^ 0x33)
<< std::endl;
std::cout << "00010001" << std::endl;
std::cout << "00110011" << std::endl;
std::cout << "--------" << std::endl;
std::cout << "00100010" << std::endl;
std::cout << std::endl;
std::cout << "0x71 ^ 0x5F = 0x"
<< std::setw(2) << std::setfill('0') << (0x71 ^ 0x5F)
<< std::endl;
std::cout << "01110001" << std::endl;
std::cout << "01011111" << std::endl;
std::cout << "--------" << std::endl;
std::cout << "00101110" << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
ビット単位のXOR演算子 ^
0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0
0x11 ^ 0x22 = 0x33
00010001
00100010
--------
00110011
0x11 ^ 0x33 = 0x22
00010001
00110011
--------
00100010
0x71 ^ 0x5F = 0x2E
01110001
01011111
--------
00101110
ビット単位のOR演算子 |
sample.cpp
#include <iostream>
#include <iomanip>
int main()
{
std::cout << "ビット単位のOR演算子 |" << std::endl;
std::cout << std::endl;
std::cout << "0 | 0 = " << (0 | 0) << std::endl;
std::cout << "0 | 1 = " << (0 | 1) << std::endl;
std::cout << "1 | 0 = " << (1 | 0) << std::endl;
std::cout << "1 | 1 = " << (1 | 1) << std::endl;
std::cout << std::endl;
std::cout << std::uppercase << std::hex;
std::cout << "0x11 | 0x22 = 0x"
<< std::setw(2) << std::setfill('0') << (0x11 | 0x22)
<< std::endl;
std::cout << "00010001" << std::endl;
std::cout << "00100010" << std::endl;
std::cout << "--------" << std::endl;
std::cout << "00110011" << std::endl;
std::cout << std::endl;
std::cout << "0x11 | 0x33 = 0x"
<< std::setw(2) << std::setfill('0') << (0x11 | 0x33)
<< std::endl;
std::cout << "00010001" << std::endl;
std::cout << "00110011" << std::endl;
std::cout << "--------" << std::endl;
std::cout << "00110011" << std::endl;
std::cout << std::endl;
std::cout << "0x71 | 0x5F = 0x"
<< std::setw(2) << std::setfill('0') << (0x71 | 0x5F)
<< std::endl;
std::cout << "01110001" << std::endl;
std::cout << "01011111" << std::endl;
std::cout << "--------" << std::endl;
std::cout << "01111111" << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
ビット単位のOR演算子 |
0 | 0 = 0
0 | 1 = 1
1 | 0 = 1
1 | 1 = 1
0x11 | 0x22 = 0x33
00010001
00100010
--------
00110011
0x11 | 0x33 = 0x33
00010001
00110011
--------
00110011
0x71 | 0x5F = 0x7F
01110001
01011111
--------
01111111
論理積(AND) &&
sample.cpp
#include <iostream>
int main()
{
int n = 1;
std::cout << "論理積(AND) &&" << std::endl;
std::cout << std::endl;
std::cout << "0 && 0 = " << (0 && 0) << std::endl;
std::cout << "1 && 0 = " << (1 && 0) << std::endl;
std::cout << "0 && 1 = " << (0 && 1) << std::endl;
std::cout << "1 && 1 = " << (1 && 1) << std::endl;
std::cout << std::endl;
std::cout << "0 && 10 = " << (0 && 10) << std::endl;
std::cout << "1 && 10 = " << (1 && 10) << std::endl;
std::cout << std::endl;
std::cout << "(n > 2) && (n < 0) = " << ((n > 2) && (n < 0)) << std::endl;
std::cout << "(n > 0) && (n < -1) = " << ((n > 0) && (n < -1)) << std::endl;
std::cout << "(n > 3) && (n < 2) = " << ((n > 3) && (n < 2)) << std::endl;
std::cout << "(n < 2) && (n > 0) = " << ((n < 2) && (n > 0)) << std::endl;
std::cout << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
論理積(AND) &&
0 && 0 = 0
1 && 0 = 0
0 && 1 = 0
1 && 1 = 1
0 && 10 = 0
1 && 10 = 1
(n > 2) && (n < 0) = 0
(n > 0) && (n < -1) = 0
(n > 3) && (n < 2) = 0
(n < 2) && (n > 0) = 1
論理和(OR) ||
sample.cpp
#include <iostream>
int main()
{
int n = 1;
std::cout << "論理和(OR) ||" << std::endl;
std::cout << std::endl;
std::cout << "0 || 0 = " << (0 || 0) << std::endl;
std::cout << "1 || 0 = " << (1 || 0) << std::endl;
std::cout << "0 || 1 = " << (0 || 1) << std::endl;
std::cout << "1 || 1 = " << (1 || 1) << std::endl;
std::cout << std::endl;
std::cout << "0 || 10 = " << (0 || 10) << std::endl;
std::cout << "1 || 10 = " << (1 || 10) << std::endl;
std::cout << std::endl;
std::cout << "(n > 2) || (n < 0) = " << ((n > 2) || (n < 0)) << std::endl;
std::cout << "(n > 0) || (n < -1) = " << ((n > 0) || (n < -1)) << std::endl;
std::cout << "(n > 3) || (n < 2) = " << ((n > 3) || (n < 2)) << std::endl;
std::cout << "(n < 2) || (n > 0) = " << ((n < 2) || (n > 0)) << std::endl;
std::cout << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
論理和(OR) ||
0 || 0 = 0
1 || 0 = 1
0 || 1 = 1
1 || 1 = 1
0 || 10 = 1
1 || 10 = 1
(n > 2) || (n < 0) = 0
(n > 0) || (n < -1) = 1
(n > 3) || (n < 2) = 1
(n < 2) || (n > 0) = 1
条件演算子 ? :
sample.cpp
#include <iostream>
int main()
{
std::cout << "条件演算子 ? :" << std::endl;
std::cout << std::endl;
for (int i=0; i<3; i++)
{
std::cout << "i < 2 ? i : -1 ---> " << (i < 2 ? i : -1) << std::endl;
std::cout << "i < 2 ? i + i + 2 : -1 - i ---> "
<< (i < 2 ? i + i + 2 : -1 - i) << std::endl;
std::cout << "i < 1 ? \"abc\" : \"efg\" ---> "
<< (i < 1 ? "abc" : "efg") << std::endl;
std::cout << std::endl;
}
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
条件演算子 ? :
i < 2 ? i : -1 ---> 0 <--- 条件式の評価結果 1
i < 2 ? i + i + 2 : -1 - i ---> 2 <--- 条件式の評価結果 1
i < 1 ? "abc" : "efg" ---> abc <--- 条件式の評価結果 1
i < 2 ? i : -1 ---> 1 <--- 条件式の評価結果 1
i < 2 ? i + i + 2 : -1 - i ---> 4 <--- 条件式の評価結果 1
i < 1 ? "abc" : "efg" ---> efg <--- 条件式の評価結果 0
i < 2 ? i : -1 ---> -1 <--- 条件式の評価結果 0
i < 2 ? i + i + 2 : -1 - i ---> -3 <--- 条件式の評価結果 0
i < 1 ? "abc" : "efg" ---> efg <--- 条件式の評価結果 0
代入演算子 = *= /= %= += -= >>= <<= &= ^= |=
sample.cpp
#include <iostream>
class Samp_c
{
int n;
public:
Samp_c(int i) : n(i) { }
int g() { return n;}
};
int main()
{
int n;
Samp_c c1(1);
Samp_c c2(2);
std::cout << "代入演算子 =" << std::endl;
// 左右両方のオペランドが算術型
n = 5;
std::cout << "n = " << n << std::endl;
// 左右両方のオペランドが同じクラス型
std::cout << "代入前 c1.g() ---> " << c1.g() << std::endl;
c1 = c2;
std::cout << "代入後 c1.g() ---> " << c1.g() << std::endl;
std::cout << std::endl;
std::cout << "複合代入演算子 *= /= %= += -=" << std::endl;
std::cout << "n = 4 --- 右オペランド = 2" << std::endl;
// *=
n = 4;
n *= 2;
std::cout << "n *= 2 ---> n = " << n << std::endl;
// /=
n = 4;
n /= 2;
std::cout << "n /= 2 ---> n = " << n << std::endl;
// %=
n = 4;
n %= 2;
std::cout << "n %= 2 ---> n = " << n << std::endl;
// +=
n = 4;
n += 2;
std::cout << "n += 2 ---> n = " << n << std::endl;
// -=
n = 4;
n -= 2;
std::cout << "n -= 2 ---> n = " << n << std::endl;
std::cout << std::endl;
std::cout << "複合代入演算子 >>= <<=" << std::endl;
// 左シフト <<=
n = 4;
n <<= 2;
std::cout << "n <<= 2 ---> n = " << n << std::endl;
// 右シフト >>=
n = 4;
n >>= 2;
std::cout << "n >>= 2 ---> n = " << n << std::endl;
std::cout << std::endl;
std::cout << "複合代入演算子 &= ^= |=" << std::endl;
std::cout << "n = 15 --- 右オペランド = 21" << std::endl;
// AND &=
n = 15;
n &= 21;
std::cout << "n &= 21 ---> n = " << n << std::endl;
// XOR ^=
n = 15;
n ^= 21;
std::cout << "n ^= 21 ---> n = " << n << std::endl;
// OR |=
n = 15;
n |= 21;
std::cout << "n |= 21 ---> n = " << n << std::endl;
std::cout << std::endl;
}
実行結果
$ gcc -Wall sample.cpp -lstdc++
$ ./a.out
代入演算子 =
n = 5
代入前 c1.g() ---> 1
代入後 c1.g() ---> 2
複合代入演算子 *= /= %= += -=
n = 4 --- 右オペランド = 2
n *= 2 ---> n = 8
n /= 2 ---> n = 2
n %= 2 ---> n = 0
n += 2 ---> n = 6
n -= 2 ---> n = 2
複合代入演算子 >>= <<=
n <<= 2 ---> n = 16
n >>= 2 ---> n = 1
複合代入演算子 &= ^= |=
n = 15 --- 右オペランド = 21
n &= 21 ---> n = 5
n ^= 21 ---> n = 26
n |= 21 ---> n = 31
コンマ演算子
sample.cpp
#include <iostream>
int main()
{
std::cout << "コンマ演算子" << std::endl;
int n1, n2;
// ( )内がコンマ演算子による処理
n2 = (n1 = 2 + 3 , n1 + 4);
std::cout << "n2 = " << n2 << std::endl;
std::cout << std::endl;
// for文の制御式内におけるコンマ演算子による処理
for (n1=0, n2=0; n1<3; n1++, n2+=5)
{
std::cout << "n1 = " << n1
<< "--- n2 = " << n2 << std::endl;
}
std::cout << std::endl;
}
実行結果
bash-5.1$ gcc -Wall sample.cpp -lstdc++
bash-5.1$ ./a.out
コンマ演算子
n2 = 9
n1 = 0--- n2 = 0
n1 = 1--- n2 = 5
n1 = 2--- n2 = 10
実行環境
GNU bash, version 5.1.16
GCC-12.2.0
GNU C Library 2.36
GNU Binutils 2.39
GCC-12.2.0
GNU C Library 2.36
GNU Binutils 2.39
コード例・出力内容中の表記
・実行例中の太字表記部分は、コマンドなどの入力された文字列を示します。
・「︙」や「...」の着色省略表記は、 実際のソースコードや出力内容などを省略加工した部分を示します。
・「︙」や「...」の着色省略表記は、 実際のソースコードや出力内容などを省略加工した部分を示します。