面向对象基本原理
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)} 是错误的