C++学习笔记03

今天学习的内容较少

类的特别成员

对于const数据成员，引用的数据成员以及类的对象成员，都要放在初始化列表中
静态成员变量必须在类外定义，所有类共享。

静态成员函数

无隐含this指针，不能直接访问非静态的数据成员和成员函数，只能访问静态数据成员和静态成员函数。对于静态成员函数，可以直接使用类名调用，因为它只能操作静态数据成员，即与某个具体对象无关。

const成员函数

不能修改数据成员，只能调用const成员函数，不能调用非const成员函数。const位于()之后，可以进行重载

单例设计模式

简介

简单来说，单例设计模式就是指一个类只有一个实例，尽管能初始化多个实例对象，但实质上返回的是同一个对象，正如你不能同时打开多个windows下的任务管理器一样。

步骤

1.将构造函数私有化，以防止外界创建单例类的对象
2.在类中定义一个静态的指针常量(private)，并在类外初始化为空
3.定义一个返回值为类指针的静态成员函数

编写简单的栈类

#include <iostream>
using namespace std;
//栈类
class Stack
{
public:
    Stack()
    {
        cout << "这是默认构造函数" << endl;
    }
    Stack(int n)
    :nums(new int[n]())
    ,capacity(n)
    {
        cout << "这是有参构造函数" << endl;
        stacksize = 0;
    }
    ~Stack()
    {
        cout << "这是析构函数" << endl;
    }
    void push(int);
    void pop();
    int top();
    bool empty();
    bool full();
    void print();

private:
    int *nums;
    int stacksize;
    int capacity;
};

void Stack::print()//打印栈中元素
{
    for(int i = 0; i < stacksize; ++i)
        cout << nums[i] << endl;
}

bool Stack::empty()
{
    return stacksize == 0;
}

bool Stack::full()
{
    return stacksize == capacity;
}

void Stack::push(int x)//压栈
{
    if(!full())
    {
        nums[stacksize] = x;
        ++stacksize;
    }
    else
    {
        cout << "栈已满，无法push" << endl;
    }
}

void Stack::pop()//弹栈
{
    if(empty())
    {
        cout << "栈空，无法弹栈" << endl;
    }
    else
    {
        --stacksize;
    }

}

int Stack::top()//获取栈顶元素
{
    return nums[stacksize-1];
}

int main(int argc, char *argv[])
{
    Stack s1(10);//初始化容量为10的栈
    s1.push(10);
    s1.push(12);
    s1.push(14);
    cout << s1.top() << endl;//输出栈顶元素
    s1.pop();
    cout << s1.top() << endl;
    //s1.print();
    return 0;
}

编写简单的队列类

利用循环队列

#include <iostream>
using namespace std;
//利用数组实现循环队列
class Queue
{
public:
    Queue()
    {
        cout << "这是默认构造函数" << endl;
    }
    Queue(int n)//设置给定大小的数组
    :capacity(n+1)
    ,frot(0)
    ,rear(0)
    ,nums(new int[n+1]())
    {
        cout << "这是有参构造函数" << endl;
    }
    ~Queue()
    {
        cout << "这是析构函数" << endl;
    }
    void push(int);
    void pop();
    int front();
    int back();
    bool empty();
    bool full();
    void print();

private:
    int *nums;
    int capacity;
    int frot;
    int rear;
};

void Queue::print()//打印队列元素
{
    if(!empty())
    {
        for(int i = frot; i != rear; i = (i+1)%capacity)
            cout << nums[i] << " ";
        cout << endl;
    }
    else
    {
        cout << "队列为空" << endl;
    }
    
}

bool Queue::empty()//判断队空
{
    return frot == rear;
}

bool Queue::full()//判断队满
{
    return frot == (rear+1)%capacity;
}

void Queue::push(int x)//入队
{
    if(!full())
    {
        nums[rear] = x;
        rear = (rear+1)%capacity;
    }
    else
    {
        cout << "队列已满，无法push" << endl;
    }
    
}

void Queue::pop()//出队
{
    if(!empty())
        frot = (frot+1)%capacity;
    else
    {
        cout << "队空，无法pop" << endl;
    }
    
}

int Queue::front()//获取队首元素
{
    return nums[frot];
}

int Queue::back()//获取队尾元素
{
    //return nums[]
    if(!empty())
    {
        for(int i = frot; i != rear; i = (i+1)%capacity)
            if((i+1)%capacity == rear)
                return nums[i];
    }
    else
        cout << "队空" << endl;
}

int main(int argc, char *argv[])
{
    Queue q(10);//初始化容量为10的队列
    for(int i = 0; i < 10; ++i)
        q.push(i);
    q.print();
    q.push(1);
    q.pop();
    q.print();
    cout << q.front() << endl;
    cout << q.back() << endl;
    return 0;
}