C++(一) ——基础性质回顾

1、c++ 基础回顾操作

1.1 函数基础操作

1、构造函数的操作

构造函数重载需要在定义中中声明实现，然后才能进行重载操作

## 分开实现构造函数的操作
class MyClass
{
public:
	MyClass();
	MyClass(int a, int b);
	~MyClass();

private:
	int a; 
	int b;
};

MyClass::MyClass()
{
}
MyClass::MyClass(int a,int b)
{
	this->a = a;
	this->b = b;
}
## 2、直接在一起实现构造函数的操作

2、普通的声明函数操作

#include<iostream>
using std::cout;
using std::endl;

class MyClass
{
public:
	MyClass();
	MyClass(int a, int b) {
		this->a = a;
		this -> b = b;
	}
	~MyClass();

private:
	int a; 
	int b;

public:
	int  getA() {
		return this->a;
	}
	int getB();
};

MyClass::MyClass()
{
}

MyClass::~MyClass()
{
} 

int MyClass::getB() {
	return this->b;
}

int main() {
	MyClass* s = new MyClass(2,3);
	cout << s->getB() << endl;
	
}

2、模板函数操作

使用模板：可以让这些程序实现与类型无关，从而使得编码操作实现泛型操作。

函数模板和类模板

函数模板：仅仅针对参数类型不同的函数；

类模板：仅仅针对数据成员和成员函数类型不同的类。

函数模板：

template <class T> void swap(T& a, T& b){}

/*
可以使用 class 或者typename
*/

类模板操作

template<class T> class A{public: T a; T b; T hy(T c, T &d);};


// 如何定义一个类模板信息
//statck.h
template <class T> class Stack {
    public:
        Stack();
        ~Stack();
        void push(T t);
        T pop();
        bool isEmpty();
    private:
        T *m_pT;        
        int m_maxSize;
        int m_size;
};

//stack.cpp
#include "stack.h"
template <class  T>  Stack<T>::Stack(){
   m_maxSize = 100;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
template <class T>  Stack<T>::~Stack() {
   delete [] m_pT ;
}
        
template <class T> void Stack<T>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T> T Stack<T>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T> bool Stack<T>::isEmpty() {
    return m_size == 0;
}

include "stdio.h"
include "stack.h"

// 如何使用类模板操作
int main()
{
	Stack<int> intStack;
	intStack.push(1);
	intStack.push(2);
	intStack.push(3);

	while(!intStack.isEmpty()) {
		printf("num:%d\n", intStack.pop());
	}

	return 0;
}

3、NULL和nullptr

c++ 11中引入了nullptr是为了解决NULL表示空指针在c++中具有二义性的问题，

NULL 在c++中既可以代表数字0，也可以代表void * 类型的指针操作。

在C 语言中的NULL

#define NULL ((void *)0)
表示的是一个空指针

与C语言不同，c++是强语言类型，void *是不能隐式转换成为其他类型的，所以编译器提供的头文件做了相应的处理

#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif

4、explict

主要是用来修饰类的构造函数，被修饰的构造函数不能发生相应的隐式类型转换，只能进行显示的类型转换，类的构造函数默认情况下下声明是隐式的即为implicit。

隐式转换即是可以由单个实参来调用的构造函数定义了一个从形参类型到该类类型的隐式转换。编译器在试图编译某一条语句时，如果某一函数的参数类型不匹配，编译器就会尝试进行隐式转换，如果隐式转换后能正确编译，编译器就会继续执行编译过程，否则报错。

对于仅有一个参数或除第一个参数外其余参数均有默认值的类构造函数，尽可能使用explicit关键字修饰。
另注意：当类的构造函数的声明和定义分别在两个文件里时，explicit只能写在构造函数的声明中，不能写在定义中。

5、function

function 作为标准库提供的函数指针

头文件: #include <functional>
语法：std::function<return_type(args_type)>

其中return_type 是函数指针的返回值类型，像上面案例中func函数的void类型。
其中args_type 是函数指针的参数类型，有多个函数参数，就可以有多个数据类型。

6、运算符的重载操作

// 声明操作
T& operator*() const;
T* operator->() const;

explicit operator bool() const;

// 实现操作
template <typename T>
T& smart_ptr<T>::operator*() const
{
	return *m_pobject;
}

template <typename T>
T* smart_ptr<T>::operator->() const
{
	return &this->operator*();
}

7、c++中虚函数和接口的关系

虚函数、纯虚函数、抽象类之间的关系

虚函数

虚函数的作用是实现动态联编，是c++ 多态地一种表现。

在程序的运行阶段动态地选择合适地成员函数，在定义了虚函数后，可以在基类和派生类中对虚函数重新定义，在派生类中重新定义了函数应于虚函数具有相同地形参个数和形参类型，以实现统一的接口，不同定义过程。

纯虚函数

如果父类的函数（方法）根本没有或者无法实现，完全要依赖子类去实现的话，可以把此函数设为

virtual 返回值类型 函数名 (函数参数) = 0;

只有类中的虚函数才能被声明为纯虚函数，普通成员函数和顶层函数均不能声明为纯虚函数。

抽象类

如果一个类包含了纯虚函数，称作此类为抽象类。抽象类无法实例化，无法创建对象，纯虚函数没有函数体，不是完整的函数，无法调用，也无法为其分配内存空间。
抽象类通常是作为基类，让派生类去实现纯虚函数，派生类必须实习那纯虚函数才能被实例化。

抽象类中除了包含纯虚函数外，还可以包含其它的成员函数（虚函数或者普通函数）和成员变量。

接口

c++ 中没有接口这一说法。