Day 67 组合，标识符作用域与可见性， 单例模式中的，懒汉，饿汉模式

1.组合，在c++中一切皆对象，而每个class不可能就一下包含了对象的所有属性和行为，这就出现了类的组合。
比如要描述计算机，计算机类有不可缺少的两个属性，一个是硬件一个是软件。而硬件又可以是一个类，包括cpu和内存
；软件也可以是一个类包括操作系统和各种应用；然而cpu，内存可以是一个类，操作系统应用又可以是一个类，，，，依次类推，，所以就有了类的组合问题

2.函数的重载要在同一作用域下

3.外层标识符在内层不可见。

4.所有静态生存期的，在main函数之前系统会初始化。

5.匿名对象，生存期完后会立即释放，生存期一般就是本函数，。因为它没有名字，所以自己执行完后别人也无法使用它，所以系统立即回收它。

6. &&n右值引用，所有匿名对象都是右值，f（10） ，匿名对象被引用后就变为左值，生存周期变长。

7.类里面的静态成员函数可以 类名::函数名 这种形式访问。

8.静态成员函数不存在this指针。

9.单例模式， cout是一个典型的单例模式，因为输出只要一个。

10.单例中的懒汉模式，与饿汉模式。
懒汉模式是调用静态函数创造时才会去堆上申请空间，当并发模式时就可能出错，应为判断条件可能还是空指针， 饿汉模式是在一开始就把堆申请好。

#include

using namespace std;

class SingelTon
{
public:
//懒汉模式
static SingelTon *create()
{
//共用一个m_p当并发时可能会申请两个空间。
if(m_p == NULL)
{ //通过判断是否为空来决定要不要在堆上，new 一个类出来
m_p = new SingelTon;
}

    return m_p;
}
static void destroy()
{
//调用delete 可以直接释放堆上的空间。
    delete m_p;
    m_p = NULL;
}
static unsigned int getCounter()
{
    return counter;
}

private:

SingelTon(){++counter;}    
SingelTon(const SingelTon &){++counter;}
~SingelTon(){--counter;}
static SingelTon *m_p;
static unsigned int counter;

};
//静态成员的定义， 成员类型，类名，:: 成员名。
SingelTon *SingelTon::m_p;
unsigned int SingelTon::counter;

int main()
{

cout << SingelTon::getCounter() << endl;
SingelTon *p = SingelTon::create();
SingelTon *q = SingelTon::create();
cout << SingelTon::getCounter() << endl;

// SingelTon s(*p);
cout << p << endl;
cout << q << endl;

return 0;

}

//饿汉模式
class SingelTon
{
public:

static SingelTon *create()
{
    return m_p;
}

private
?/构造
SingelTon( ) {}
//复制构造
SingelTon(const SingelTon &){ }
~SingelTon(){}
//这里只是声明
static SingelTon *m_p;
};

//一开始就在堆上申请一个对象
SingelTon *SingelTon::m_p = new SingelTon;

int main()
{
return 0;
}

---

#include
//命名空间
using namespace std;

class CPU
{
public:
CPU(int n) : Fre(n){cout << “CPU()” << endl;}
~CPU(){cout << “~CPU()” << endl;}
void showFre()
{
cout << Fre << endl;
}

int Fre;

};

class MEM
{
public:
MEM(){cout << “MEM()” << endl;}
~MEM(){cout << “~MEM()” << endl;}
};

class HW
{
public:
HW(int fre) : cpu(fre){cout << “HW()” << endl;}
~HW(){cout << “~HW()” << endl;}
CPU cpu;
MEM mem;
};

class APP
{
public:
APP(){cout << “APP()” << endl;}
~APP(){cout << “~APP()” << endl;}
};

class OS
{
public:
OS(){cout << “OS()” << endl;}
~OS(){cout << “~OS()” << endl;}
};

class SW
{
public:
SW(){cout << “SW()” << endl;}
~SW(){cout << “~SW()” << endl;}
APP app;
OS os;
};

class Computer
{
public:
//构造
Computer(int n) : hw(n){cout << “Computer()” << endl;}
//析构
~Computer(){cout << “~Computer()” << endl;}
//是个类类型
HW hw;
SW sw;
};

int main（）
{

 Computer c(1000);
 //可以访问到最后的showFre函数
 c.hw.cpu.showFre();

}

---

2.数据的共享与保护
例如函数名，变量名都是标识符。
命名空间作用域 -》类作用域 -》局部作用域

#include

using namespace std;

//函数原型作用域，作用域只在函数里面
void add(int a, int b);

//局部作用域
void fn(int i)
{
int a;
{ //b作用域出了括号之后就结束了
int b;
}
}

//类作用域
class Demo
{
public:
void fn()
{
m_i = 100;
}
void fm(int &m_i)
{
this->m_i = 100;
// ::read();
}

void read()
{

}

//此作用域在类结束之后就结束了
int m_i;

enum WEEK {Mon, Fri};
class BBB
{

};

};

//命名空间作用域，比如有一个类名，要使用两次，但程序中类名是不能重复的，因此可以使用namespace来区分，比如一个是XA AAA, 另外一个是BJ AAA;

namespace XA
{
class AAA
{
public:
AAA()
{
std::cout << “XA::AAA()” << std::endl;
}

};
int g_i;
namespace BLQ
{
    class BBB
    {

    };
}
void fn(){}

}

//命名空间作用域
namespace BJ
{
void fn(int ){}
class AAA
{
public:
AAA()
{
std::cout << “BJ::AAA()” << std::endl;
}
};
}

//匿名命名空间,没有类名
//namespace
//{
// class Demo
// {

// };
//}

//全局命名空间作用域
void foo()
{

}

#include
#include
#include
using namespace XA;

void fn()
{
int d;
}

int i = 1;

int main()
{
int i = 10;

{
    int i = 100;
    cout << i << endl;
}

// double d;
// std::string s;
// Demo d;
//全局命名空间作用域
// ::foo(); // 表明为全局的
// AAA a;
// BLQ::BBB b;
// fn();
// g_i = 100;

// ::是作用域分辨符
// Demo::BBB b;
// Demo d;
// d.m_i = 10;
// d.fm();
return 0;
}