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