C++速学day2

news2024/11/18 23:28:17

xia复习

上一天的学习内容：

重点：1、封装———— 就是对类的抽象，将一种对象的共性抽象成一个类。

2、三个函数——-构造函数/复制构造函数/析构函数

注意：析构函数和构造函数的调用顺序刚好相反。

新内容

两个类的关系

1、 has-a //

类的组合，描述的就是一个类内嵌其他类的对象作为成员的情况，他们之间的关系是一种包含和被包含的关系。

eg： //在线类中内嵌两个点的对象

class Point
{
public:
    Point(int x=0, int y=0);
    Point(const Point &other):m_x(other.m_x),m_y(other.m_y)
    {
        cout<<"&Point" <<endl;
    }
    ~Point()
    {
        cout<<"~Point" <<endl;
    }
    void setX(int x);
    void setY(int y);
    int getX();
    int getY();
    void show();
private:
    int m_x, m_y;
};

Point::Point(int x, int y):m_x(x),m_y(y)
{
    cout<<"Point(int )" <<endl;
}

void Point::setX(int x)
{
    m_x = x;
}

void Point::setY(int y)
{
    m_y = y;
}

void Point::show()
{
    cout<< m_x<<","<< m_y <<endl;
}

int Point::getX()
{
    return m_x;
}

int Point::getY()
{
    return m_y;
}

class Line
{
public:
    Line(int x1,int y1,int x2,int y2):m_p1(x1,y1),m_p2(x2,y2)
    {
        cout<< "Line (int int int int )"<< endl;
    }

    Line(const Point &p1,const Point &p2):m_p1(p1),m_p2(p2)
    {
        cout<< "Line (const Point &p1,&p2)"<< endl;
    }
    ~Line()
    {
        cout<< "~Line"<< endl;
    }
    void show()
    {
        m_p1.show();
        cout << "->"<< endl;
        m_p2.show();
    }
private:
    Point m_p1,m_p2;
};

2、 is-a //

类的继承关系。

前向引用声明

class A;
class B
{
public:
    A *a;
    void fn(A &a)
    {
    }
}
class A
{
public:
    B *b;    
}

若是不在classB之前声明A B中的A对象的定义会报错。

而且这里在类中定义的不能是对象，需要是指针。或者是一个引用的值，不能是对象。

注意：在编程在多文件时注意尽量在源文件中包头文件，不在头文件中包头文件。

UML类图

示例如上

标识符作用域与可见性的问题

C++的比C语言扩展了一些问题：

1、类的作用域

类内访问，类外访问

2、命名空间作用域：

namespace 命名空间

namespace CD
{
	class Clock
	{
	
	};
	void foo（）
	{
	
	}
}

namespace XA
{
	class Clock
	{
	
	};
}
int main(void)
{
    CD::Clock c;
}

这个时候创建的c 就是CD 命名空间的c 。

using CD：：Clock； //先声明CD中的Clock 这个函数后面使用的时候默认是CD命名空间的
后面使用的时候可以直接写函数或者类；

using namespace CD；
CD中所有的内容都不需要加”：：“去访问。

匿名命名空间：

namespace
{
	class Clock
	{
		
	}
}

这个匿名命名空间的类和操作只能在本文件中使用。
（类似于C语言中全局变量前的static）

全局命名空间作用域
全局空间的标识符（函数）在使用时候加上两个：：就是全局命名空间作用域的函数

void read（）
{
    ::read(fd,p,10);    //这里的read就不是他自己而是全局命名空间作用域的read
}

作用域和作用域之间是可以互相包含的

1、标识符要声明在前，引用灾后
2、在同一作用域中，不能声明同名标识符
3、在没有相互包含关系的不同作用域中同名标识符互不相影响。
4、如果两个或多个具有包含关系的作用域，外层不可见

静态：生存期与程序运行周期相同 ----> static 全局变量
动态：

static修饰之后只会被创建一次不会重复创建并且结束时间为程序结束的时候。
若是加了static的静态变量没有初始化那它默认为 0；

匿名对象可以通过&来进行起别名
const Clock &ref = Clcok（10，20，30）；
但此时的ref不能.showtime（）；只能读不能写。

&&ref 右值引用

lvalue locatable
       如果可以取地址就是左值
rvalue
       如果不能取地址就是右值

所有的匿名对象都是右值

右值向左值的转换
&&i= 10；
i = 100；
此时输出就是100；

C++的循环：

int a[] = {1,2,3,4,5,6,7,8,9,0};
int len = sizeof(a) / sizeof(a[0]);

for(int x: a)             //base range for 
{
    cout << x << endl ;    
}


for(int i = 0; i < len ; ++i)
{
    cout<< a[i] <<endl ; 
}

他们两个输出结果相同。

单例模式：

23种设计模式其中之一比较简单的不适用虚函数的
单例模式：
一个类的类对象只能创建一个出来这个类的对象只能有一个
这就是单例模式。

class SingelTon
{
public:
    static SingelTon * getIntance()
    {
        if(m_p == NULL)
        {
            m_p = new SingelTon;
        }
        return m_p;
    }
    static void destroyIntance()
    {
        delete m_p;
        m_p = NULL;
    }
    static int getCounter()
    {
        return counter;
    }
private:
    SingelTon()
    {
        counter++;
    }
    ~SingelTon()
    {
        counter--;
    }
    static SingelTon *m_p;
    static int counter;
};

SingelTon* SingelTon::m_p = NULL;
int SingelTon::counter;


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

	 
输出结果：
1
1
0x1c02280
0x1c02280
0