exiler

// Windows_X64環境でMinGw GCC 9.2.0 32_bitを使用した例
// 1Byte = 8bit
#include<iostream>
using namespace std;
int main(){
  cout<< "int * "<<sizeof(int*)*8<<endl; // 32 bits
  cout<< "bool "<<sizeof(bool)*8<<endl;  // 8 bits
  cout<< "char "<<sizeof(char)*8<<endl;  // 8bits
  cout<< "wchar_t "<<sizeof(wchar_t)*8<<endl;  // 16bits
  cout<< "char16_t "<<sizeof(char16_t )*8<<endl;  // 16bits
  cout<< "char32_t "<<sizeof(char32_t )*8<<endl;  // 32bits
  cout<< "short "<<sizeof(short )*8<<endl;  // 16bits
  cout<< "int "<<sizeof(int )*8<<endl;  // 32bits
  cout<< "long "<<sizeof(long )*8<<endl;  // 32bits
  cout<< "long long"<<sizeof(long long)*8<<endl;  // 64bits
  cout<< "float "<<sizeof(float)*8<<endl;  // 32bits
  cout<< "double "<<sizeof(double)*8<<endl; // 64bits
  cout<< "long double "<<sizeof(long double)*8<<endl; //96bits
return 0;
}

#include<iostream>
using namespace std;
int main() {
	int i = 42;
	if (i) {
		i = 0;
	}
	cout << "i = " << i << endl;  // i=0
	return 0;
}

//test01.cpp
#include<iostream>
using namespace std;
int main() {
	int i = 42;
	if (i) {
		i = 0;
	}
	cout << "i = " << i << endl;  // i=0
	return 0;
}

//test02.cpp
#include<iostream>
int main() {
	unsigned u = 10;
	int i = -42;
	std::cout << i + i << std::endl; //-84
	std::cout << u + i << std::endl; //4294967264
	return 0;
}

//test03.cpp
#include<iostream>
int main() {
	for (int i = 10; i >= 0; --i) {
		std::cout << i << std::endl;
	}
	return 0;
} //正常出力

//test04.cpp
#include<iostream>
int main() {
	for (unsigned u = 10; u >= 0; --u) {   //符号なし数は0未満にならない
		std::cout << u << std::endl;    //無限ループ、ctrl+cで終了
	}
	return 0;
}

//test05.cpp
#include<iostream>
int main() {
	unsigned u = 10, u2 = 42;
	std::cout << u2 - u << std::endl;  //32
	std::cout << u - u2 << std::endl;  //4294967264
	int i = 10, i2 = 42;
	std::cout << i2 - i << std::endl;  //32
	std::cout << i - i2 << std::endl;  //-32
	std::cout << i - u << std::endl;  //0
	std::cout << u - i << std::endl; //0
	return 0;
}

#include<iostream>
int main() {
	int month = 9, day = 7;
	int month1 = 09, day1 = 07; //0で始まると8進数として扱われる
    // [Error] invalid digit "9" in octal constant
	return 0;
}

エスケープシーケンス:
改行'\n'   水平タブ'\t'   ビープ'\a'
垂直タブ'\v'  バックスペース'\b'  二重引用符'\"'
バックスラッシュ'\\'  疑問符'\?'  単一引用符'\''   キャリッジリターン'\r' 

一般化エスケープシーケンス:'\x'の後に1つまたは複数の16進数、または'\'の後に1、2、3個の8進数
'\7'ビープ '\12'改行 '\40'スペース
'\0'空文字 '\115'文字M '\x4d'文字M

//test05.cpp
#include<iostream>
int main() {
	std::cout << '\n';  //改行
	std::cout << "\tHi!\n";  //タブ,Hi!,改行
	std::cout << "\v\?\abc\b\n";  //垂直タブ,?,ビープ,bc,バックスペース,改行
	std::cout << "Hi \x4dO\115!\n";  //Hi MOM!,改行
	std::cout << '\115' << '\n';  //M,改行
	return 0;
}

#include<iostream>
std::string global_str;  //グローバル変数global_strを定義、初期値は空文字列
int global_int;  //グローバル変数global_intを定義、初期値は0
int main() {
	int local_int; //ローカル変数は初期化されず、初期値は未定義
	std::string local_str; 
    //local_strはstringクラスのオブジェクトで、その値はクラスによって決まります。空文字列です。
	return 0;
}

extern int i;  //iを宣言するが定義しない 
int j;  //jを宣言し定義する 
// 明示的な初期化を含む宣言は定義になります：
extern double pi = 3.14;  //定義
// 関数体内でexternキーワードでマークされた変数を初期化しようとするとエラーが発生します。

extern int ix = 1024; //定義
int iy;  //定義
extern int iz;  //宣言

//C++キーワード
alignas  continue  friend  register  true
alignof  decltype  goto  reinterpret_cast  try
asm  default  if  return  typedef
auto  delete  inline  short  typeid
bool  do  int  signed  typename
break  double  long  sizeof  union
case  dynamic_cast  mutable  static  unsigned
catch  else  namespace  static_assert  using
char  enum  new  static_cast  virtual
char16_t explicit  noexcept  struct  void
char16_t export  nullptr  switch  volatile
class  extern  operator  template  wchar_t
const  false  private  this  while
constexpr  float  protected  thread_local
const_cast  for  public  throw
//C++演算子の代替名
and  bitand  compl  not_eq  or_eq  xor_eq
and_eq  bitor  not  or  xor

 int double = 3.14;  //エラー
 int _;
 int catch-22;  //エラー
 int 1_or_2 = 1;  //エラー
 double Double = 3.14;

//scope.cpp
#include <iostream>
// このプログラムは説明目的のみです：関数がグローバル変数を使用し、同時に同じ名前のローカル変数を定義するのは悪いスタイルです。
int reused = 42; // reusedはグローバルスコープ
int main() {
	int unique = 0; // uniqueはブロックスコープ
// 出力 #1: グローバルreusedを使用; 42 0を出力
	std::cout << reused << " " << unique << std::endl;
	int reused = 0; // 新しいローカルオブジェクトreusedがグローバルreusedを隠します。
// 出力 #2: ローカルreusedを使用; 0 0を出力
	std::cout << reused << " " << unique << std::endl; 
    //この時、グローバル変数は同名のローカル変数に覆われます。
// 出力 #3: 明示的にグローバルreusedを要求; 42 0を出力
	std::cout << ::reused << " " << unique << std::endl;  
    //グローバル変数を使用
	return 0;
}

#include <iostream>
int i = 42;
int main() {
	int i = 100;
	int j = i;
// jの値は100で、ローカル変数iがグローバル変数iを覆っています。
	std::cout << j << std::endl; //100
	return 0;
}

#include <iostream>
int main() {
//以下のプログラムは合法ですか？合法であれば、何を出力しますか？
	int i = 100, sum = 0;
	for (int i = 0; i != 10; ++i)
		sum += i;  //この時の変数iはforループ内でのみ有効
	std::cout << i << " " << sum << std::endl;
//合法出力:100 45 
	return 0;
}

 int &refVal = val; 

 int &refVal2;  //エラー、参照は初期化されなければなりません 

int *ip1,*ip2;
// ip1とip2はどちらもint型オブジェクトのポインタです。
double dp,*dp2
// dp2はdouble型オブジェクトを指すポインタで、dpはdouble型です。

int i=42;
int *p = &i; 

int ival = 42;
int *p = &ival; //pはivalのアドレスを格納し、pはvalを指すポインタです。

double dval;
double *pd = &dval;//正しい
double *pd2 = pd;//正しい

int *pi = pd;//エラー、型不一致
pi = &dval;//エラー、doubleオブジェクトのアドレスをintポインタに代入しようとしています。

#include <iostream>
int main() {
// ポインタがオブジェクトを指している場合、間接参照演算子（演算子'*'）を使用してオブジェクトにアクセスします。
	int ival = 42;
	int *p = &ival;
	std::cout << *p;// pポインタが指すオブジェクトのデータを出力します。
	*p = 0;
	std::cout << ival; // 0
	return 0;
}

int *p1=nullptr; //空ポインタを使用します。
int *p2 = 0;//p2はリテラル定数0で初期化されます。
// include<cstdlib>
int *p3 = NULL;//int *p3=0 NULLプリプロセッサ変数
int zero = 0;
p1 = zero; //エラー、int変数をポインタに直接代入することはできません。

//ポインタと参照の主な違いを説明します。
    
//参照は別のオブジェクトの別名ですが、ポインタ自体はオブジェクトです。
//参照は初期化が必要で、一度定義された参照は他のオブジェクトにバインドを変更できません。
//ポインタは定義時に初期値を設定する必要はなく、他のオブジェクトを指すように再代入できます。

int i = 42;
int *pi = 0;//piは初期化されておらず、何も指していません。
int *pi2 = &i;//pi2はiを指します。
int *pi3;//もしpi3がブロック内で定義されている場合、pi3の値は不明です。

pi3 = pi2;//pi3はpi2と同じオブジェクトiを指します。
pi2 = 0;//pi2はオブジェクトを指していません。

// 代入文は常に左側のオブジェクトを変更します。
pi = &ival;//piはivalを指します。
*pi = 0;//ivalの値が変更され、piは変更されません。

//以下の定義を説明してください。これらの定義の中に不正なものはありますか？もしあれば、なぜですか？
int i = 0;
(a) double* dp = &i;
(b) int *ip = i;
(c) int *p = &i;
(a): 不正。double型のポインタをintに指すことはできません。
(b): 不正。int変数をポインタに代入することはできません。
(c): 正当。

int ival = 1024;
int *p1=0;
int *p2=&ival;
// ポインタ値0、条件はfalse
if(p1)
	//...
// p2ポインタは0でない、条件値はtrue
if(p2)
	//...
// ポインタ比較
if(p1==p2)
	//...

// 1つの文で異なる型の変数を定義します。
int i=1024,
*p=&i,&r=i;

int* p;//合法ですが誤解を招く可能性があります。
int* p1,p2;//p1はポインタ、p2はintです。
int *p1,*p2;//p1とp2は両方ともポインタです。
または
int *p1;
int *p2;

#include <iostream>
using namespace std;
int main() {
	int ival = 1024;
	int *pi = &ival;  //piはint型を指します。
	int **ppi = &pi; //ppiはint型ポインタを指します。
// 間接参照
	cout << "The value of ival\n"  
	     << "direct value: " << ival << "\n"
	     << "indirect value: " << *pi << "\n"
	     << "doubly indirect value: " << **ppi
	     << endl;
	return 0;
	//The value of ival
	//direct value: 1024
	//indirect value: 1024
	//doubly indirect value: 1024
}

int i=42;
int *p;
int *&r = p;  //rはポインタpの参照です。
r = &i;  //pはiを指します。
*r=0;  //i=0

次の変数の型と値を説明してください。
(a) int* ip, i, &r = i;
(b) int i,*ip = 0;
(c) int* ip, ip2;

(a): ipはint型のポインタ、iはint、rはiの参照です。
(b): iはint、ipは空ポインタです。
(c): ipはint型のポインタ、ip2はintです。

double obj = 3.14,
*pd = &obj;
void *pv = &obj; //objは任意の型のオブジェクトです。
pv = pd;//void*は任意の型を格納でき、使用時に強制的に型変換できます。

const int bufSize = 512;
bufSize = 512;//エラー、constオブジェクトに値を書き込もうとしています。

const int i= getSize();
const int j=42;
const int k;//エラー、kは初期化されていない定数です。

int i=42;
const int ci=i;
int j=ci;

//file_1.ccで定義された初期化定数は他のファイルからアクセス可能です。
extern const int bufSize = fcn();

//file_1.h ヘッダーファイル
extern const int bufSize ;//file_1.ccで定義されたbufSizeと同じです。

const int buf;  // 不合法, constオブジェクトは初期化されなければなりません。
int cnt = 0;  // 合法
const int sz = cnt;  // 合法
++cnt; ++sz;  // 不合法, constオブジェクトは変更できません。

const int ci=1024;
const int &r1=ci;
r1=42;  //エラー、r1は定数の参照です。
int &r2 = ci;  //エラー、非常数参照が定数オブジェクトを指そうとしています。

int i=42;
const int &r1=i;  //const int&をintオブジェクトにバインドすることが許可されます。
const int &r2=42;//r2は定数参照です。
const int &r3=r1*2;//r3は定数参照です。
int &r4=r1*2;//エラー、r4は普通の非常数参照です。

//定数参照が別の型にバインドされるとどうなるか？
double dval = 3.14;
const int &ri=dval;
//コンパイラは上記のコードを次のように変換します。
const int temp=dval;//一時的な整数変数を生成します。
const int &ri=temp;//riはこの一時変数にバインドされます。

double dval = 3.14;
int &ri = dval; //エラー

int i = 42;
int &r1 = i; //r1はiをバインドします。
const int &r2 = i;  //r2はiをバインドします。r2を通じてiを変更することはできません。
r1 = 0;  //ok、r1は非常数です。
r2 = 0;  //エラー、r2は定数参照です。

int errNumb=0;
int *const curErr=&errNumb;// curErrは定数で、常にerrNumbを指します（アドレスは変更できません）。
const double pi=3.1415;
const double *const pip= π//pipは定数で、*pipも定数です。
//pipは定数オブジェクトを指す定数ポインタです（値とアドレスの両方を変更できません）。
*pip = 2.72;//エラー *pipは定数です。
if(*curErr){
	errorHandler();
	*curErr=0;//ok *curErrは定数ではありません。
}

//以下の初期化は合法ですか？理由を説明してください。
int i = -1, &r = 0; // 不合法、rはオブジェクトを参照する必要があります。
int *const p2 = &i2; // 合法、定数ポインタです。
const int i = -1, &r = 0; // 合法
const int *const p3 = &i2; // 合法
const int *p1 = &i2; // 合法
const int &const r2; // 不合法、r2は参照であり、トップレベルのconstがありません。
const int i2 = i, &r = i; // 合法

//以下の定義は何を意味しますか？不合法なものを選んでください。
int i,*const cp; // 不合法、constポインタは初期化されなければなりません。
int *p1,*const p2; // 不合法、constポインタは初期化されなければなりません。
const int ic, &r = ic; // 不合法、const intは初期化されなければなりません。
const int *const p3; // 不合法、constポインタは初期化されなければなりません。
const int *p; // 合法。const intを指すポインタです。

//前の練習で定義された変数があると仮定すると、以下の文は合法ですか？理由を説明してください。
i = ic; // 合法、定数を普通の変数に代入します。
p1 = p3; // 不合法、p3はconstポインタで、普通のポインタに代入することはできません。
p1 = ⁣ // 不合法、普通のポインタは定数を指すことはできません。

const int * const p3 = ⁣ // 合法、p3は定数ポインタで、定数を指します。
p3 = ⁣ //この時不合法、p3は定数です。

int * const p2 = p1; // 合法、普通のポインタを定数ポインタに代入できます。
p2 = p1;//この時不合法、p2は定数です。

const int ic = *p3; // 合法、p3から値を取得した後、icに代入します。
ic = *p3;//この時不合法、icは定数です。

int i=0;
int *const p1=&i;//p1は定数で、トップレベルconstです。
const int ci=42;//ciは定数で、トップレベルconstです。
const int *p2=&ci;//*p2は定数で、ボトムレベルconstです。
const int *const p3=p2;//右側はトップレベルconst、左側はボトムレベルconstです。
const int &r =ci;//参照のために使用されるconstはすべてボトムレベルconstです。

// コピー時、トップレベルconstは影響を受けません。
i=ci;//ciの値をコピーし、ciのトップレベルconstは影響を受けません。
p2=p3;//p2とp3は指すオブジェクトの型が同じで、p3のトップレベルconst部分は影響を与えません。

// コピー時にはボトムレベルconst資格が厳密に要求され、データ型の変換が可能です。
int *p =p3;//エラー、p3はボトムレベルconstを含んでおり、pは含んでいません。
p2=p3;//ok、p2とp3はボトムレベルconstで、コピー時にはトップレベルconstを無視します。
p2=&i; //ok、int*はconst int*に変換できます。
int &r=ci;//エラー、普通のint&はint定数にバインドできません。
const int &r2=i;//ok、const int&はintにバインドできます。

//次の文に対して、オブジェクトがトップレベルconstまたはボトムレベルconstとして宣言されているかを説明してください。
const int v2 = 0; int v1 = v2;
int *p1 = &v1, &r1 = v1;
const int *p2 = &v2,
*const p3 = &i, &r2 = v2;
//v2はトップレベルconst、p2はボトムレベルconst、p3はトップレベルconstでボトムレベルconstでもあり、r2はボトムレベルconstです。

//前の練習で定義された変数があると仮定すると、以下の文は合法ですか？理由を説明してください。
r1 = v2; // 合法、トップレベルconstはコピー時に影響を受けません。
p1 = p2; // 不合法、p2はボトムレベルconstで、p1はボトムレベルconstでなければなりません。
p2 = p1; // 合法、int*はconst int*に変換できます。
p1 = p3; // 不合法、p3はボトムレベルconstで、p1はボトムレベルconstでなければなりません。
p2 = p3; // 合法、p2とp3はボトムレベルconstで、コピー時にはトップレベルconstを無視します。

//オブジェクト（式）が定数式であるかどうかは、データ型と初期値によって決まります。
const int max_file=30;  //max_fileは定数式です。
const int limit = max_file+1;  //limitは定数式です。
int staff_size = 7;  //staff_sizeは定数式ではありません。
const int sz = get_size();  //実行時に取得されるため、szは定数式です。

constexpr int mf = 20;  //20は定数式です。
constexpr int limit = mf+1;  //mf+1は定数式です。
constexpr int sz = get_size(); //get_size()がconstexpr関数であるかどうかに依存します。

const int *p=nullptr;//pは定数を指すポインタです。
constexpr int *q=nullptr;//qは定数ポインタです。
//constexprは定義されたオブジェクトをトップレベルに置きます。
constexpr int *nq=nullptr;//nqは定数ポインタです。
int j=0;
constexpr int i=42;//iは定数です。
//i,jは関数外で定義されています。
constexpr const int *p=&i;//pは定数ポインタで、整数定数iを指します。
constexpr int *p1=&j;//p1は定数ポインタで、整数jを指します。

// 複合型（ポインタなど）に対して元の式に戻して理解することはできません。
typedef char *pstring;  // pstringはchar*のエイリアスです。
const pstring cstr = 0; // cstrはcharを指す定数ポインタです。
const pstring *ps;//psはconst charを指すポインタです。
//基本データ型はポインタではなくconst charです。

 auto sz = 0, pi =3.14；//エラー、型が一致しません。

int i = 0, &r = i; 
auto a = r; //aの型はintと推論されます。

//トップレベルのconstは無視されます。
const int ci = i;
auto b = ci;//intと推論され、トップレベルのconstは無視されます。

const int ci = 1; const auto f = ci;
//型はintと推論され、トップレベルのconstが必要な場合は自分でconstを追加する必要があります。

decltype(expression)

int x = 42;
decltype(x) y; // yの型はintです。

double square(double value) {
    return value * value;
}

decltype(square(3.14)) result; // resultの型はdoubleです。

struct Point {
    int x;
    int y;
};

Point p;
decltype(p.x) a; // aの型はintです。

template<typename T, typename U>
auto multiply(T a, U b) -> decltype(a * b) {
    return a * b;
}

int main() {
    int x = 5;
    double y = 3.14;
    auto result = multiply(x, y); // resultの型はdoubleです。

    return 0;
}

decltype(f()) sum = x; //sumの型は関数fの戻り値の型と推論されます。

//Sales_data.h
#ifndef SALES_DATA_H
#define SALES_DATA_H

#include <string>
struct Sales_data {
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
};
#endif

//Sales_data.cpp
#include <iostream>
#include <string>
#include "Sales_data.h"
int main() {
	Sales_data data1, data2;
// data1とdata2に読み込むコード
	double price = 0; // 書籍ごとの価格、総収益を計算するために使用されます。
// 最初の取引を読み取ります：ISBN、販売された書籍の数、価格
	std::cin >> data1.bookNo >> data1.units_sold >> price;
// 価格と販売数から総収益を計算します。
	data1.revenue = data1.units_sold * price;
// 2番目の取引を読み取ります
	std::cin >> data2.bookNo >> data2.units_sold >> price;
	data2.revenue = data2.units_sold * price;
// data1とdata2が同じISBNを持っているかどうかを確認するコード
// もしそうであれば、data1とdata2の合計を印刷します。
	if (data1.bookNo == data2.bookNo) {
		unsigned totalCnt = data1.units_sold + data2.units_sold;
		double totalRevenue = data1.revenue + data2.revenue;
// 印刷：ISBN、総販売数、総収益、書籍ごとの平均価格
		std::cout << data1.bookNo << " " << totalCnt
		          << " " << totalRevenue << " ";
		if (totalCnt != 0)
			std::cout << totalRevenue / totalCnt << std::endl;
		else
			std::cout << "(no sales)" << std::endl;
		return 0; // 成功を示します
	} else { // 取引は同じISBNではありませんでした
		std::cerr << "データは同じISBNを参照する必要があります"
		          << std::endl;
		return -1; // 失敗を示します
	}
}

#ifndef SALES_DATA_H //SALES_DATA_Hが未定義の場合は真
#define SALES_DATA_H
strct Sale_data{
	...
}
#endif