C++笔记8.20

面向对象基本原理
OOP（封装encapsulation，继承，多态性）
接受同一种消息/具有相同接口为同一类型
接口：通信 保护
程序需要隐藏一些东西，保护内部
两种人：写/用 类

售票机例子

class TicketMachine{
public:
	void showPrompt();
	void getMoney();
	void printTicket();
	void showBalance();
	void printError();
private:
	const int PRICE;
	int balance;
	int total;
};	

创建新类会生成.h和.cpp文件
声明 定义 实体
：：两个冒号为解析符，表示该函数属于前者类
若前面没有类，即表示为全局函数，不断递归调用自己
：：a++ 全局a
a- - 表示为类中变量

头文件（合同）
类的声明：
头文件中放declaration extern global
源文件中放definition ；int global是定义而不是声明
include:编译预处理，把.h文件放入.cpp文件中，形成.ii文件
g++ a.cpp --save-temps 保存中间文件
.cpp ->预编译.ii ->编译 .s->汇编.o->linker
输出所有warning --save-temps -Wall
头文件中声明：
extern变量 函数原型（没有大括号） 类/结构体声明
#include “xx.h” 当前目录
#include <xx.h> 编译器认定的系统头文件目录
C++ #include < xx >同二 include < iostream >
unix系统不在乎文件后缀名

标准头文件结构：#ifndef _A_H _ #define… #endif
如果宏已经定义了，则#define…内容不会被编译
Tips：一个类的头文件里只放一个类

本地变量只在函数运行时有效；
本地变量与成员变量同时存在，只有前者有效；
成员变量定义在函数之外，在对象生成期间永远存在（类的作用域，在整个类的成员函数中都可以使用）
参数与本地变量属性一致，放在堆栈中
声明不指出具体位置

class A{
private:
	int i;
public:
	void f();
};
void A::f()
{
	i=20;
	cout<<i<<" "<<endl;
}		

int main()
{
	A a;
	a.f();
}	

f中可以自由使用i
若需访问a.i,需将i前的private删掉
类不是实体，没有变量（不知道变量的位置）
C中：

struct B{
	int i;
};
void f(struct B*p)
{
	p->i = 20;
	cout <<p->i<<endl;
}	
int main(){
	B b;
	f(&b);
}	

void A::f()
{
	i=20;
	printf("A::f()--&i=%p",&i);
}
int main(){
printf("&a=%p\n",$a);
printf("&a.i=%p\n",&(a.i));
//此时对象中只有一个成员变量，它们地址相同
}
	

隐藏的参数 this（指针）；
第一次的时候this就是a

void A::f(){
	this-i =20;
	printf("this=%p\n",this);
}	

构造和析构
变量并没有初始化（效率） 数据处于不确定状态

class Point {
public:
	void init(int x, int y);
	void print() const;
	void move(int dx, int dy);
private:
	int x;
	int y;
};

void main() {
	Point a;
	a.init(1, 2);
	a.move(2, 2);
	a.print();
}

visual studio debug会帮忙填充 0xcd（烫）
footprint调试法 足迹分析

构造函数：constructor
1.名字与类相同
2.无任何返回类型

class X{
	int i;
public:
	X();
};	

class A {
public:
	int i;
	A();
};

A::A() {
	i = 0;
	printf("A::A()--this=%p\n", this);
}
void main() {
	A a;
}

构造函数自动会被调用

Tree(int i){...}
Tree t(12);

class A {
public:
	int i;
	A(int j);
};

A::A(int j) {
	i = j;
	printf("A::A()--this=%p\n", this);
}
void main() {
	A a(10);
	cout<<a.i<<endl;
}

析构函数 destructor
对象被结束前调用（离开大括号），无返回类型，无参数
用于内部整理和回收

class Y{
public:
	~Y();
}

对象初始化
C语言允许在函数任何地方定义变量，只需在第一次使用该变量之前
空间已经分配好，但是运行到那一句才能构造

int c[]={1,2,3,4}
-sizeof c / sizeof *c
struct X{int i;float f ;char c;};
X x1 = {1,2.2,'c'}
X x2[3] = {{1,1.1,'a'},{2,2.2,'b'}};
struct Y{float f; int i; Y(int a);};
Y y1[] = {Y(1),Y(2),Y(3)};

C++中struct和类一样，里面可以有函数

没有参数的构造函数：default constructor
若给了参数 则Y y[2]={Y(1)} 是错误的