2021/01/15 C++程序设计学习 11-15课时

课时11——new & delete

本地变量
malloc动态地得到一块内存
C++用新了两个新的运算符来动态分配内存
new Stash
new 类的时候，会分配空间并且调用构造函数
new int;
new Stash;
new int[10];
运算符必然有返回值。
delete
delete p;
delete[] p;
先调用析构函数，再释放空间。

int* psome = new int[10];返回块的第一元素的地址。
delete [] psome;会调用所有的对象的析构函数。
int *p=new int; // 到堆栈里面寻找一块合适的空间，然后P指向这个空间，然后会有一张表记录存地址和字节大小，比如 p 和 4BYTE，然后会依次记录动态分配的东西。
内部数据表！
int *a=new int[10];

Student *q=new Student();
Student *r=new Student[10];

delete p;// 会先在记录表中查找p，取得地址知道有多大，然后去删除空间。
如果 a++; delete[] a;那么系统在表里面找不到这个搜地址
delete q; //先析构，然后回收空间
delete r; // 因为没有方括号，那么空间照样收回，会认为你只有一个，还会回收160大小的内存（因为表里回收的大小没有变），但析构函数只会调用一个（后面九个class的成员析构并不会被执行）。
delete[] r; //正确的回收。

this是指向对象的指针
TIPS for new and delete

• 不要用delete去释放new没有分配的空间
• 不要释放两次同一空间
• 方括号要成对出现（new[] delete[]）
• 释放NULL指针指向的空间是安全的，它不做任何事情，留着这个口子是为了让你的代码好些

内存泄漏是不能存在的。

课时12——访问限制

c++中的访问限制存在于不同的类之间，但是不存在于同一类的不同对象之间。例如：

class A {
private:  
   int i = 1;
public: 
   void f(A * p) {cout << p->i;} 
};

int mian(）
{
   A a, b;
   b.f(&a);
}

b是可以通过类中提供的 f(）函数来访问a中的的私有变量。

Friends
你可以声明别人是你的朋友，这样别人就可以访问你的，（别人说你的朋友，可不能访问！！！）
实例

struct X;

struct Y{
	viod f(X*);
};

struct X{//Definition
private:
	int i;
public:
	void initialize();
	friend void g(X* , int);//Global friend
	friend void Y::f(X* );//Struct member friend
	friend struct Z;//Entire struct is a friend
	friend void h();
};

void X::initialize(){
	i = 0;
}

void g(X* x, int i){
	x->i = 47;
}

struct Z{
private:
	int j;
	
...

};

class vs.struct

• class defaults to private
• struct defaults to public.

课时13——初始化列表

class Point {
private:
	const float x, y;
	Point(float xa = 0.0, float ya = 0.0)
		: y(ya), x(xa) {}//：一个冒号之后大括号之前是初始化
		//初始化会在构造函数之前被执行
};

Initialization vs.assignment

Student::Student (string s) :name (s) { }
	/*initialization	初始化
	before constructor	在构造函数之前*/	
Student::Student (string s) { name = s;}
	//assignment		只是一个赋值

1.初始化列表 构造函数后加冒号 +成员变量+圆括号中为初始值
A() :i (0) { }
2.初始化列表早于构造函数执行
3.建议：类的所有成员变量用初始化列表初始化

课时14——对象组合

软件重用，组合使用已有的对象组合成新的对象
Composition 重组

例子 Example

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 ( namem,
  address), m_balance ( 0, cents) { }
 
void SavingsAccount ::print () { 
	m_saver.print ();
	m_balance.print ();
}

如果你的类里面有成员对象是变量我们就应该在initialization(就是构造函数：后面的部分)里进行初始化，而不要放到constructors 构造函数里进行初始

Public vs.Private

class SavingsAccount {
public:
	Person m_saver; ...};	//assume
 Person class has set_name ()
SavingAccount account;
account.m_saver.set_name("Fred" );

这样把成员变量做成public虽然方便但是别人都能使用你的成员变量，就相当于把自己的心脏放在外面，随便一个人都可以过来按两下，违背oop的原则！！
所以不建议这样做！

课时15——继承

---

PS:使用英语并不是装X…实际本人英语非常差，希望通过写文章，可以熟悉一些计算机英语术语，如有不适还请见谅~

例子 Example

class A{
public:
	A():i(0) { cout << "A::A()" << endl; }
	~A() { cout << "A::~A()" << endl;}
	void print() { cout << "A::f()" << i << endl;}
protected:
	void set(int ii) { i = ii; }
private:
	int i;
}:

class B: public A {
public:
	void f(){
			set(20);
			//i = 30;	error 不能使用父类的private：里的东西
			print();
	}
}；

int main()
{
	B b;
	//b.set(10);	error: 子类只能在类里使用父类的protected：里的东西
	b.print();
	
	returen 0;
}

C++ access control ( C++ 访问控制)

• public 公有的
• private 私有的，只有class的成员函数访问的变量或函数
• protected 只有class和子子孙孙可以访问（也就是只有子类可以访问）