C++ 基础01

1 byte (字节)= 8 bit(位)
上述最大尺寸的单位是：bit
一个字符（如a)占1 byte,即8 bit。
sizeof(int)=4(bytes)
strlen()=(letters)
sizeof(double)=8(bytes)
十六进制0、1、2、3、4、5、6、7、8、9和字母A、B、C、D、E、F（a、b、c、d、e、f）

#include<iostream>
using namespace std;
int main()
{
	bool b = 5;
	cout << b;     //结果1 	
	int i = b;
	cout << i;		//结果1 
	i = 3.15;
	cout << i;		//结果3 
	double pi = i;
	cout << pi;
	unsigned char c = 15;  //-1 超过了 0-255区间  
	cout << c;
	signed char c2 = 255;
	cout << c2;
	
return 0;
}

2.literal
'a’字符a literal
"dddd"字符串literal
20 十进制
024 八进制 以0开头
0x14 以0x或0X 十六进制

3.escape sequence转义序列
\n或\12 换行符 \r回车符 \ 反斜线
\t 横向制表符 \v 纵向制表符
\a或\7 报警（响铃）符 \r 回车符 \f 进纸符 \b退格符
" 双引号 ’ 单引号
\40 空格
\0 空字符
\115字符M
\x4d 字符M

std::cout << '/n'; //转到新一行
std::cout << "\tHi!\n" //输出一个制表符，输出“Hi!”,转到新一行

4.引用reference &d
引用并非对象，相反的，他只是为一个已经存在的兑现所以的另一个名字。
定义了一个引用之后，对其进行的所有操作都是在与之绑定的对象上进行的；
不允许对引用赋值！！！

int ival=1024;
int &refVal= ival;   //refVal指向ival，即ival是refVal的另一个名称。
refVal = 10;   //把10赋值给了refVal，也就是赋值给了refVal的对象ival
int li= refVal; //与li=ival的执行结果与一样
int &refVal3=refVal; //refVAal3绑定到了那个与refVal绑定的对象上，这里就是绑定到了ival上
int i= refVal; //i的初始化为ival的值
int i=1025,i3=2048; // i和i2都是int
int &r=i,r2=i2;
int i3=1024,&ri=i3; //r3 is int,ri is reference with i3
int &r3=i3,&r4=i2;  //r3 and r4 are reference
int &refVal4=10;  //错误：引用类型的初始值必须是一个对象
double dval=3.14;
int &refVal5=dval; //错误：此处引用类型的初始值不稀释int型对象

5.指针pointer point to *p
指针本身就是一个对象，允许对指针赋值和拷贝，而且指针的生命周期内它可以先后只想几个不同的对象
指针无需在定义时赋初值。

int *ip1, *ip2; //ip1和ip2都是指向int型对象的指针
double dp, *dp2; //dp2是指向double型对象的指针，dp是double型对象

指针存放某个对象的地址，要想获取对象的地址，需要使用取地址符（&）

int ival =42;
int *p= &ival; // p是存放变量ival的地址，或者说p是指向变量ival的指针。

承接上，因为把p定义为一个指向int 的指针，随后初始化p令其指向名为ival的int对象。因为引用不是对象，所以没有实际地址，所以不能定义指向引用的指针。

double dval;
double *pd= &dval;  //正确：初始值是double型对象的地址
double *pd2=pd;   //正确：初始值是指向double对象的指针

//错误
int *pi = pd;  //错误：指针pi的类型和pd的类型不匹配
pi = &dval;   //错误：试图把double对象的地址赋给int型指针

利用指针访问对象
如果指针指向了一个对象，则允许使用解引用符（*）来访问该对象

int ival =42;
int *p= &ival; // p是存放变量ival的地址，或者说p是指向变量ival的指针。
cout << *p; //由符号*得到指针p所指的对象，输出42

对指针解引用会得出所指的对象，因此如果给解引用的结果赋值，实际上也就是给指针指的对象赋值

*p = 0;  //由符号*得到指针p所指的对象，即可经由p变量ival赋值
count << *p; // 输出0

如上述程序所示，为*p赋值实际上是为p所指的对象赋值。
6. 举例，(& )和 ( * )

int i = 3;
int &r = i; //&紧随类型名字出现，因此是声明的一部分，r是一个引用
int *p;  //*紧随类型名字出现，因此是声明的一部分，p是一个指针
p= &i;  //&出现在表达式中，是一个取地址符
*p=i; //*出现在表达式中，是一个解引用符
int &r2=*p; //&是声明的一部分，*是一个解引用符。

7.空指针 null pointer,不指向任何对象，在试图使用一个指针之前代码可以首先检查它是否为空。以下列出几个生成空指针的方法

int *p1=nullptr; //等价于int *pl=0;
int *p2=0; // 直接将p2初始化为字面常量0
// 需要首先#include cstdlib
int *p3 = NULL; //等价于 int *p3 = 0;

赋值和指针

int i=42; 
int *pi=0;  //pi被初始化，但没有指向任何对象
int *pi2=&i; //pi2被初始化，存有i的地址
int *pi3;//如果pi3定义于块内，则pi3的值是无法确定的
pi3 =pi2; //pi3和pi2指向同一个对象i
pi2=0; //现在pi2不指向任何对象了

赋值永远改变的是等号左侧的对象
其他指针

8.void* 指针 。可以存放任何对象的地址

double obj=3,14, *pd=&obj;//正确，void*能存放任意类型对象的地址
void *pv= &obj; //obj可以是任意类型的对象
pv=pd; pv可以存放任意类型的指针

指向指针的指针
*** 表示指向指针的指针的指针

int ival=1024;
int *pi=&ival; //pi指向一个int类型的数
int **ppi=π //ppi指向一个int型的指针的指针

9.pi是指向int型数的指针，而ppi是指向int型指针的指针
为了访问最原始的那个对象，需要对指针的指针做两次解引用

count << "The value of ival\n"
	  << "direct value:" << ival<< "\n"  //直接输出
	  << "indirect value:"<< *pi <<"\n"  //通过int型指针pi输出
	  << "doubly indirect value:" << **ppi  //通过两次解引用ppi，取得ival的值
	  << endl;

10.指向指针的引用

int i =42;
int*p; //p是一个int型指针
int *&r = p; //r是一个对指针p的引用

r=&i; //r引用了一个指针，因此给r赋值&i就是令p指向i
*r=0;//解引用r得到i，也就是p指向的对象，将i的值改为0

11. const限定符 一旦创建，const对象一旦创建后不能再被改变，所以const对象必须初始化

const int bufSize=512; //输入缓冲区大小
bufSize-512; //错误：试图向const对象写值

const int i=get_size(); //正确：运行时初始化
const int j=4; //正确：编译时初始化
const int k; //错误：k是一个未经初始化的常量

默认状态下，const对象仅在文件内有效，解决办法

// file_1.cc 定义并初始化了一个常量。该常量能被其他文件访问
extern const int bufSize=fcn();
//file_1.h 头文件
extern const int bufSize;//与file_1.cc中定义的bufSize是同一个

如上述程序所示，file_1.cc定义并初始化了bufSize。因为这条语句包含了初始值，所以它显然是一次定义。然而，因为bufSize是一个常量，必须用extern加以限定使其被其他文件使用。
file_1.h 头文件中的声明也由extern做了限定，其作用是指明bufSize并非文件所独有，它的定义将在别处出现。
对常量的引用

const int ci=1024;
const int &r1=ci;

//指针
#include<iostream>
using namespace std;	
int main()
{
	//1.指针的定义
	int a=10; //定义整型变量a
	//指针定义语法：数据类型 * 变量名;
	int * p;
	
	//指针变量赋值
	p = &a; //指针指向变量a的地址;
	
	cout << &a << endl; //打印数据a的地址
	cout << p << endl; //打印指针变量p
	
	//2.指针的使用
	//通过*操作指针变量指向的内存
	cout << "*p= " << *p <<endl; 
	
	//3.指针所占内存空间 
	
	cout << *p << endl; // *解引用
	cout << sizeof(p) <<endl;
	cout << sizeof(char*) << endl;
	cout << sizeof(float *) << endl;
	cout << sizeof(double *) << endl;
	
	//4.const 
	
	int b=10;
	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改 
	const int * p1 = &a;
	p1 = &b; //正确
	//*p1 =100; 报错 
	
	//const 修饰的是常量，指针指向不可以改，指针指向的值可以更改
	int * const p2 = &a;
	//p2 = &b; 错误
	*p2 = 100; //正确 解锁赋值
	
	 //5.利用指针访问数组中元素
	 int arr[]= {1,2,3,4,5,6,7,8,9,10};
	 int * p3 = arr;  //指向数组的指针
	 
	 cout << "第一个元素：" << arr[0] << endl;
	 cout << "指针访问第一个元素：" << *p3 <<endl;
	 for (int i =0; i <10; i++)
	 {
	 	//利用指针遍历数组
		 cout << *p3 << endl;
		 p3++; 	
	 }
	  
	
	return 0;