OOP笔记一

参考资料：

• 翁恺 C++ B站
• 陈翔 C++ 学校
• C++程序设计教程（第二版） 钱能
• C++面向对象程序设计（第二版） 谭浩强
• C++ Primer中文版（第5版）       

基础：

C  java

笔记：

头文件（。h）：
一个头文件只放一个class的声明propter
放声明而不是实现
#define if等语句防止头文件被重复调用而造成冲突
#include 包含进来
相同名文件（。cpp）：
放函数的body，即实现
永远不能使用include包含进来

abstract 抽象
ignore datails 忽视不重要的细节

constructor 构造函数

local variable 本地变量 局部变量？只存在于函数内部

成员变量 class声明中的变量 在。h文件 fields

如果本地变量和成员变量名字一样 根据就近原则 取local variable

parameters 函数参数

class：：函数（function） 某个class的函数    ：：的作用

extern +变量或函数 全局

class只是声明一个类型 并不会占用内存空间
而只有创造出这个class的object对象以后 才真正的实现这个对象的所有内容占用内存空间

同一个class中的函数可以随意使用class中的成员变量
class中的成员变量只是声明，并不存在
class的对象的成员变量才是真实存在的

class的函数却又属于class本身而不是属于该class的对象
每个对象调用的都是公共的class函数

this：
this is a hidden parameter for all member functions，with the type of class
每个class中的函数都有一个隐藏的参数this
this->成员变量 这样可以在成员函数变量的名字与成员变量重复的情况下使用成员变量
this是关键字本质是指针 即class这个类的某个对象的地址
通过这样 公共的成员函数才能分辨是哪一个具体class对象调用了该函数

class的某个对象被创造时每一个成员变量都需要初始化 这点与java不一样

constructor：
构造函数|构造器
函数名字与class的名字一样
没有返回类型
class X
{int i；
 public：
X();
};
在创造class的对象时会被自动调用
在初始化对象时可以加入参数

destructor：
析构函数
在对象要被消灭时自动调用 释放占用的资源
~加名字 命名与构造函数一样
没有参数

在c++中：class和struct绝大多数一样

default constructor：
无参数的构造函数 不管是系统自动给你的还是你自己的
如果在创造对象时没有明确指出对象的参数值，那么就默认调用default constructor 但前提是你有该函数 否则系统会报错 猜想？：如果你不写构造函数 那么系统会自动给你一个default constructor ；但是如果你明确写出来一个构造函数，不管有没有参数，那么系统就不会帮你生成一个ds了。

new：创造一个对象 类似malloc
delete：消灭一个对象 类似free

new：
1.先分配空间
2.再调用构造函数
3.返回空间的地址

delete：
先调用析构函数
在释放空间
delete p
delete 【】p  new有【】的情况 加【】使每一个元素的析构函数都能被调用
int *psome=new int【10】；
delete 【】psome；

int *p=new int；
delete p；

class student
student *q=new student【10】
delete q
student *r=new student【10】
delete【】 r

class A
{
private:
        int i;
        int *p;
public: 
        A(){p=0;};
        ~A(){delete p};
        void f(){p=new int;};
}

setting limits 访问限制：
public  公开 谁都可以访问
private 私有 只有该class的成员函数可以访问成员变量或函数
protected  class或子孙可以访问

private是针对class而言与对象无关。同一个class的对象可以访问其他对象的private

friend：
允许global function全局函数，另一个class的成员函数，或者另一个class作为friends

别人是你的朋友 而不能说是你是别人的朋友 别人可以访问你的private成员

struct X;   //前置声明 因为Y要用到X
struct Y
{
void f(X*);  //X还未被定义 所以只能使用X指针类型
};
struct X
{
private:
int i;
public:
void a();
friend void g(X*,int);
friend Y::f(X*);
friend struct z;
friend void h();
};

class缺省，即默认是private
struct是public

Initializer list：
初始化表

class Point
{
private：
const float x，y；
Point（float xa=0.0，float ya=0.0）：y(ya),x(xa){}; //叫初始化--initialization
};
先会做初始化的工作，在做构造函数

作为对比：
class Point
{
private:
const float x,y;
Point(float xa=0.0,float ya=0.0){x=xa;y=ya;};   //叫赋值assignment
};

成员的所有变量都要用第一种方式完成初始化而不用第二种。因为用第一种就不需要default constructor
子类继承父类class时，子类的构造函数对于父类的构造函数的初始化也要用第一种
总之，尽量用第一种 而不是第二种

resuing the implementation
重用--组合
construct new object with esiting object
fully：另一个对象本身就是你的一个成员
by reference ：成员通过引用（本质就是指针）来访问另外一个对象

class Person{...};
class Currency{...};
class SavingsAccount
{
public:
SavingsAccount(const char *name,const char *address,int cents);
~SavingsAccount();
void print();
private:
Person m_saver;
Currency m_balance;
};
初始化
SavingsAccount::SavingsAccount(const char *name,const char* address,
int cents):m_saver(name,address),m_balance(0,cents){}；

void SavingsAccount::print()
{
m_saver.print();
m_balance.print();
};

Initializer list在构造函数之前就完成初始化
尽管其他class是class的成员，但这些class的界限是分明的。

resuing the interface
inheritance
重用--继承

接口interface通过某个class的public部分，应许其他人访问 同时private隐藏了其他部分，不应许访问

base\super\parent class      基类
dervied class sub child class  派生类

class B:public A{};
B是A的子类
B继承了A的所有 包括A的构造函数。但是对于A的private部分（通常是数据），B不能直接使用，而是要通过A中的protected修饰的函数来间接调用。protected只能由class及该class的dervied class 来调用
class A
{
public：
A（int ii）:i(ii){..}
~A(){}
private:
int i;
}
class B:public A
{
B():A(15){}          //子类完成对于父类的初始化
}

父类先构造，在子类构造
子类先析构，父类在构造
对于同名函数 子类会把父类的屏蔽掉

：：前面指明是哪一个类，可以是std

overload 重载：函数的名字一样，但是参数不一样 
如果仅仅是函数返回值不同，那么不可以

default argument：
int a（int m，int n=0）  //n预先给出，从右到左
只能在。h函数原型（声明）中不能在。c实现中
调用 a（10）    //m=10 n=0
尽量不要使用

尽量用已存在的代码来设计代码 避免重复

inline function

未完待续。。。