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;  //error
 int _;
 int catch-22;  //error
 int 1_or_2 = 1;  //error
 double Double = 3.14;

//scope.cpp
#include <iostream>
// Program for illustration purposes only: It is bad style for a function
// to use a global variable and also define a local variable with the same
int reused = 42; // reused has global scope
int main() {
	int unique = 0; // unique has block scope
// output #1: uses global reused; prints 42 0
	std::cout << reused << " " << unique << std::endl;
	int reused = 0; // new, local object named reused hides global reused
// output #2: uses local reused; prints 0 0
	std::cout << reused << " " << unique << std::endl; 
    //此時全局變量被同名的局部變量覆蓋
// output #3: explicitly requests the global reused; prints 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)
	//...

//一條語句定義不同類型變量
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;//error，試圖寫值到const對象

const int i= getSize();
const int j=42;
const int k;//error,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;  //error r1是對常量的引用
int &r2 = ci;  //error,試圖讓非常量引用指向一個常量對象

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;//error，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; //error

int i = 42;
int &r1 = i; //r1綁定i
const int &r2 = i;  //r2綁定i，不允許通過r2修改i
r1 = 0;  //ok，r1非常量
r2 = 0;  //error，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;//error *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 取值後是一個 int 然後賦值給 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 int &r =ci;//用於聲明引用的const都是底層const

//拷貝時，頂層const不受影響
i=ci;//拷貝ci的值，ci頂層const，無影響
p2=p3;//p2 p3所指對象類型相同 p3頂層const部分不影響

//拷貝時嚴格要求相同的底層const資格,數據類型能夠轉換。
int *p =p3;//error p3包含底層const定義，p沒有
p2=p3;//ok p2 p3都是底層const
p2=&i; //ok int* 轉const int*
int &r=ci;//error 普通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。

//假設已有上一個練習中所做的那些聲明，則下面的哪些語句是合法的？
//請說明頂層const和底層const在每個例子中有何體現。
r1 = v2; // 合法, 頂層const在拷貝時不受影響
p1 = p2; // 不合法, p2 是底層const，如果要拷貝必須要求 p1 也是底層const
p2 = p1; // 合法, int* 可以轉換成const int*
p1 = p3; // 不合法, p3 是一個底層const，p1 不是
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是一個指針，對象是指向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;
// code to read into data1 and data2
	double price = 0; // price per book, used to calculate total revenue
// read the first transactions: ISBN, number of books sold, price per b
	std::cin >> data1.bookNo >> data1.units_sold >> price;
// calculate total revenue from price and units_sold
	data1.revenue = data1.units_sold * price;
// read the second transaction
	std::cin >> data2.bookNo >> data2.units_sold >> price;
	data2.revenue = data2.units_sold * price;
// code to check whether data1 and data2 have the same ISBN
// and if so print the sum of data1 and data2
	if (data1.bookNo == data2.bookNo) {
		unsigned totalCnt = data1.units_sold + data2.units_sold;
		double totalRevenue = data1.revenue + data2.revenue;
// print: ISBN, total sold, total revenue, average price per book
		std::cout << data1.bookNo << " " << totalCnt
		          << " " << totalRevenue << " ";
		if (totalCnt != 0)
			std::cout << totalRevenue / totalCnt << std::endl;
		else
			std::cout << "(no sales)" << std::endl;
		return 0; // indicate success
	} else { // transactions weren't for the same ISBN
		std::cerr << "Data must refer to the same ISBN"
		          << std::endl;
		return -1; // indicate failure
	}
}

#ifndef SALES_DATA_H //SALES_DATA_H未定義時為真
#define SALES_DATA_H
strct Sale_data{
	...
}
#endif