C/C++编程笔记

控制输出位数
cout<

数组初始化为0
memset(a,0,sizeof(a))；

截取字符串
strsub(npos，size)函数，其中npos为开始位置，size为截取大小

求字符串长度
str.length();

将输入的字符型数字由char类型（ascii码）转为int类型
ch-48；
ch-'0';

为字符数组赋值
双引号是字符串，单引号是求字符的ASCII码；
char a[3]={"A","B","C"};

C语言中采取“向零取整”，即取整后向零靠拢。5/3=1;-5/3=-1

幂运算：pow() 函数的用法
#include 
8.0 ^ 3： pow(8.0, 3);

数字与字符如何拆分
text="88折"; 
text由88折变成88
一个汉字占2个字节，length()测的是字节
text=text.substr(0,text.length()-2);

控制输出位数 以及 如何求百分数及输出百分数
#include 
两个int型整数相除求百分数，先把前一个数强制转换为double再*100
setiosflags(ios::fixed)<

取余（%）时，参加运算的两个数均须为整数

自增自减
在使用i之前，先使i的值加（减）1
++i,–-i
在使用i之后，使i的值加（减）1
i++,i-- 

复合赋值运算符
+=、-=、*=、/=、%=
例子
sum=sum+n; 
sum+=n;

字符串的截取
mystring="abcdefghijklm";

substr(mystring,0,5); 
显示 "abcde"
substr(mystring,6); 
显示 "fghijklm"
substr(mystring,-2);
显示“lm”
substr(mystrng,-4);
显示“jklm”。

结构体的结构
分号不能少
struct Provinces
{
	
};

（结构体）数组作为函数参数无需引用&，因为数组名就是地址，无需取地址
void Input(Provinces ProvincesList[],int & total)

文件指针（Ｃ语言）
用一个指针变量指向一个文件，通过指针对文件进行操作。
定义文件指针
FILE* 指针名;
FILE大写。
FILE是由系统已定义的一个结构，该结构中含有文件名、文件状态和文件当前位置等信息。
FILE *fp；表示fp是指向FILE结构的指针变量，通过 fp 即可找存放某个文件信息的结构变量，
然后按结构变量提供的信息找到该文件，实施对文件的操作。
习惯上也笼统地把fp称为指向一个文件的指针。
文件的打开与关闭文件在进行读写操作之前要先打开，使用完毕要关闭。
所谓打开文件，实际上是建立文件的各种有关信息，并使文件指针指向该文件，以便进行其它操作。
关闭文件则断开指针与文件之间的联系，也就禁止再对该文件进行操作。

文件打开函数fopen()

文件指针名=fopen(文件名，使用文件方式);
FILE *fp；
fp=("file.txt","r");
其中，“文件指针名”必须是被说明为FILE 类型的指针变量，“文件名”是被打开文件的文件名。 
“使用文件方式”是指文件的类型和操作要求。“文件名”是字符串常量或字符串数组。

更改文件指针位置函数fseek()
用 法: int fseek(FILE *stream, long offset, int fromwhere);//offset 偏移量 Δ delta
fseek(fp,100L,0);把fp指针移动到离文件开头100字节处；
fseek(fp,100L,1);把fp指针移动到离文件当前位置100字节处；
fseek(fp,-100L,2);把fp指针退回到离文件结尾100字节处。

模板
void printMenu()
{
	cout<<"Menu"<>ch;
	switch(ch) 
	{
		case '1':break;
		case '2':break;
		case '3':break;
		case '4':break;
		case '5':break;
		case '6':break;
		case '7':break;
		case '8':break;
		case '9':break;
		case '0':break;
		case 'a':break;
	}
}

================又臭又长的笔记，我自己都懒得看==============

假设有一个 int 类型的变量 a，pa 是指向它的指针，那么*&a和&*pa分别是什么意思呢？

*&a可以理解为*(&a)，&a表示取变量 a 的地址（等价于 pa），*(&a)表示取这个地址上的数据（等价于 *pa），绕来绕去，又回到了原点，*&a仍然等价于 a。

&*pa可以理解为&(*pa)，*pa表示取得 pa 指向的数据（等价于 a），&(*pa)表示数据的地址（等价于 &a），所以&*pa等价于 pa。 

指针变量存储了数据的地址，通过指针变量能够获得该地址上的数据，格式为： 
*pointer;
p 代表的是 a 中的数据，它等价于 a，可以将另外的一份数据赋值给它，也可以将它赋值给另外的一个变量。

*在不同的场景下有不同的作用：*可以用在指针变量的定义中，表明这是一个指针变量，以和普通变量区分开；使用指针变量时在前面加*表示获取指针指向的数据，或者说表示的是指针指向的数据本身。

也就是说，定义指针变量时的*和使用指针变量时的*意义完全不同。以下面的语句为例： 
int *p = &a;
*p = 100;
第1行代码中*用来指明 p 是一个指针变量，第2行代码中*用来获取指针指向的数据。

需要注意的是，给指针变量本身赋值时不能加*。修改上面的语句： 
int *p;
p = &a;
*p = 100;
第2行代码中的 p 前面就不能加*。

指针变量也可以出现在普通变量能出现的任何表达式中，例如： 
int x, y, *px = &x, *py = &y;
y = *px + 5;  //表示把x的内容加5并赋给y，*px+5相当于(*px)+5
y = ++*px;  //px的内容加上1之后赋给y，++*px相当于++(*px)
y = *px++;  //相当于y=(*px)++
py = px;  //把一个指针的值赋给另一个指针

在变量名前面加星号*，格式为： 
datatype *name;
*表示这是一个指针变量，datatype表示该指针变量所指向的数据的类型 。 
int *p1;
p1 是一个指向 int 类型数据的指针变量，至于 p1 究竟指向哪一份数据，应该由赋予它的值决定。再如： 
int a = 100;
int *p_a = &a;
在定义指针变量 p_a 的同时对它进行初始化，并将变量 a 的地址赋予它，此时 p_a 就指向了 a。值得注意的是，p_a 需要的一个地址，a 前面必须要加取地址符&，否则是不对的。

和普通变量一样，指针变量也可以被多次写入。

*是一个特殊符号，表明一个变量是指针变量，定义 p1、p2 时必须带*。而给 p1、p2 赋值时，因为已经知道了它是一个指针变量，就没必要多此一举再带上*，后边可以像使用普通变量一样来使用指针变量。也就是说，定义指针变量时必须带*，给指针变量赋值时不能带*。

变量名、函数名、字符串名和数组名在本质上是一样的，它们都是地址的助记符，但在编写代码的过程中，我们认为变量名表示的是数据本身，而函数名、字符串名和数组名表示的是代码块或数据块的首地址。

①按值传递:
将实参的值传给形参。调用函数时时为形参开辟存储空间。形参的值改变，而实参的值不变。
②地址传递:
将实参的地址传给对应形参，使形参与实参公用一段存储空间，形参的变化就是形参的变化。

③引用传递
本质上是一个别名。
int &p=a;
//p就是a;声明引用的同时必须初始化。
void swap(int&p1，int&p2);
swap(a，b);
//p1就是a;p2就是b;

为了保证类的封装性，类中的指针成员所指向的内存空间必须在类的定义中自行独立开辟和释放。

Book::Book(char *a, char *b, int c)
{
name = new char[strlen(a)+1];
author=new char[strlen(b)+1];
strcpy(name,a);
strcpy(author,b);
sale=c;
} 
Book bk3(name,author,sale);

①自动存储（自动变量、局部变量）
自动存储，也叫做自动变量，比如int num = 10; 这个num就属于自动变量。
所谓自动，代表它会自动申请内存，也会自动释放内存，自动变量是保存在栈里的（后进先出）。
 
如果大家觉得很难理解，那么，换一个名称——局部变量。
这个好理解了吧？局部变量在离开函数，或者离开它所属的代码块之后，就会被释放。
 
而Value v = Value(100); 、int num = 10; 这些都是局部变量，一旦离开函数或者离开它的作用域，就会被释放。
比如把int num; 作为成员变量，那么，在这个类被释放的时候，num变量也会被释放。
这就是为什么我们在创建了这么多int、float等基本类型的变量之后，不需要去释放它们。
因为它们是自动被释放的。
 
②动态存储
自动变量有很大的好处，那就是不需要我们去管内存方面的事情，但是，有时候我们不希望有这样的自动释放内存。
我们希望自己去控制什么时候释放对象，这时候就要用到new了。
我们都知道，new了之后，如果不调用相应delete的话，申请到的内存空间是永远都不会被释放的。
这就是动态存储了，我们自己来申请内存，自己来释放内存。
当然，内存泄露的罪魁祸首之一也正是new~！
因为正常人都会有疏忽的时候，并且当程序足够庞大、逻辑足够复杂的时候，有些地方调用了new，却疏忽了delete是再正常不过了。

new是一个操作符，而malloc是一个库函数；
new能够自动计算需要分配的内存空间，而malloc需要手工计算字节数；
new计算空间是通过数据类型，而malloc通过字节大小；
new和delete带具有具体类型的指针，而malloc和free则是void *；
new是类型安全的，但是malloc不是，例如int *p = new float[2];这样编译器会报错，但是int *p = malloc(2*sizeof(int));这样是不会报错的；
new操作符可以重载，而malloc不可以；
new可以调用构造函数，但是malloc不可以；


从上面我们可以看出，new操作符的作用要比malloc的作用强大，而且malloc有的功能，使用new也可以做到，那么我们为什么还需要保留malloc呢？答案是在C++中，经常需要外部链接调用C的库，而C中管理动态内存需要使用malloc，所以我们就需要保留下malloc。

①建立一块内存空间，为一个整型变量的长度，把空间地址转换成指向整型的指针赋值给前面的整型指针变量。
②malloc()函数的作用是分配制定字节数的空间
sizeof()为单目运算 求出对应类型所占用的字节数
(类型名)为单目运算 为强制类型转换
要注意的是 malloce函数申请得到的空间是无类型的空间 必须强制转换成对应指针可以指向的空间的类型 
这里定义的是int *p 所以p指针只能指向int型空间
sizeof(int) 求得int类型所占的字节数
malloc(sizeof(int)) 申请一个跟int所占的空间大小一样的空间
(int*)malloc(sizeof(int)) 将申请得到的空间地址转换成了int类型空间地址
最后就可以赋值给指向int型空间的p指针了 

每一个成员函数都包含一个this指针，它的值是当前被调用的成员函数所在的对象的起始地址。