main.cpp

#include <stdlib.h>
#include <string>
#include "MyArray.h"
using namespace std;

/*******************
类模板：
 定义类模板MyArry
 成员函数：构造函数、析构函数、display函数
 数据成元：m_pArr
 *******************/

//使用MyArray这个类
int main(void){
    MyArray<int,5,6> arr;//实例化一个对象
    arr.display(); 
    return 0;
}

MyArry.h:
//


#ifndef UNTITLED_MYARRAY_H
#define UNTITLED_MYARRAY_H



#include <iostream>
using namespace std;

//必须将类的声明和类的定义写在同一个.h文件中

template <typename T,int KSize,int KVal>//类的前面一行写上
class MyArray
{
public:
    MyArray();
    ~MyArray()
    {
        delete []m_pArr;
        m_pArr = NULL;
    }
    void display();

private:
    T *m_pArr;
};

template <typename T,int KSize,int KVal>
MyArray<T,KSize,KVal>::MyArray()
{
    m_pArr = new T[KSize];//在构造函数中定义m_pArr为一个T型数组
    for(int i = 0;i < KSize;i++){
        m_pArr[i] = KVal;
    }
}
//
//template <typename T,int KSize,int KVal>//每一个函数定义前都要加
//MyArray<T,KSize,KVal>::~MyArray()//类名后要加<参数的名字>，然后开始相关定义
//{
//    delete []m_pArr;
//}

template <typename T,int KSize,int KVal>
void MyArray<T,KSize,KVal>::display()
{
    for(int i = 0;i < KSize;i++)
    {
        cout << m_pArr[i] << endl;
    }
}
#endif //UNTITLED_MYARRAY_H

C++中的类模板：

各种类很多地方重复，只有数据类型不一样时，用到类模板

定义的方法：

template <class T>
class MyArray{
public:
   void display(){}
private:
   T *m_pArr;//用T定义了一个数据成员的指针
}

但在类外定义个一个成员函数时：

template <class T>//每定义一个成员函数都需要在前面加这么一行代码
void MyArray<T>::display(){
   ...
}

在使用时，实例化一个对象需要在类名后边加<>:

类模板中多个参数的使用情况：

使用的时候，而且类外定义时：

使用时：

特别提醒：模板代码不能分离编译

#include <iostream>
using namespace std;

/**
 * 定义模板函数swapNum
 * 实现功能：交换两个数的位置
 */
template <typename T>
void Swap(T &a, T &b)
{
   T temp = a;
   a = b;
   b = temp;
}

int main(void)
{
   int x = 10;
   int y = 20;
   // 调用模板函数
   Swap<int>(x,y);
   cout << "x = " << x << endl;
   cout << "y = " << y << endl;
   return 0;
}

Swap注意大写，不要和标准库的swap冲突。

//函数模板的定义及使用方法
#include <iostream>
#include <stdlib.h>
using namespace std;
/*************************/
/*函数模板
   要求定义函数模板display
   */
/*************************/
template <typename T>
void display(T a){
   cout<<a<<endl;
}

//定义有两个参数的函数模板
template<typename T,class S>
void display(T t,S s){
   cout<<t<<endl;
   cout<<s<<endl;
}

//定义有两个参数的函数模板,其中一个参数为类型参数，一个为变量，这个变量在实例化时就变成一个常量
template<typename T,int KSize>
void display(T a){
   for(int i = 0;i < KSize; i++){
      cout << a << endl;
   }
}

int main(void){
   display<double>(10.98);
   display<int>(10);
   display<int,double>(5,8.3);
   display<int,5>(6);
   return 0;
}

/Users/gaoyuli/CLionProjects/untitled/cmake-build-debug/untitled10.981058.366666Process finished with exit code 0

为什么要有模板：

int max(int a,int b){return (a>b)?a:b;}
int max(float a,float b){return (a>b)?a:b;}
int max(char a,char b){return (a>b)?a:b;}
//除了类型不一样其他逻辑都一样
方案：把类型作为参数传进计算机


        关键字：template 模版 typename class 作用相同，这里的class不是定义类的，而是表明数据类型的。
当要定义一个函数模板：

通过template来声明一个函数的模板，通过class或者typename来声明一个参数，参数表示类型：

具体使用：

第一行是计算机自动判断

如果不使用函数模版时，不产生代码，因为计算机也不知道具体实例化怎样的函数

变量作为模板的参数：

多参数函数模板：

函数的模板与重载：

当我们使用时，通过三个不同的函数模板可以实例化出三个不同的模板函数，这三个模板函数之间就形成了重载关系，只有使用函数模板时，产生出真正代码后，才能称得上是2重载关系。

运算符重载：给原有运算符于新的功能

另一个例子：

+号本身并没有这个功能<<也是

运算符重载的本质：函数重载

后略

关键字：static 静态

静态数据成员，静态成员函数：

静态数据成员不依赖于是否实例化而存在，所以不在构造函数中进行实例化，其实例化往往是单独进行的，其初始化不要加static；

而普通数据成员则只能在类实例化为对象之后才存在。

访问坦克数量的方法有两种：1.不通过对象，直接通过类2.可以定义对象，加.号的方式:

在内存中，静态数据成员和普通数据成员的区别：

若一个对象都不产生的话，若用静态的成员函数调用普通的数据成员或成员函数，则会报错。（因为还没产生）

从this指针谈静态成员函数：

7:38后不太懂，先略过：

友元类的定义及使用方法：

可以在Circle类中定义Coordiate的对象，并且可以在Circle类中任意使用Coordinate类的成员和成员函数：

关于友元的注意事项：

友元关系不可传递

友元关系的单向性

友元声明的形式：函数、类及数量不受限制

友元只是封装的补充，不是一个很好的语法

不急，未做笔记

友元函数：全局函数，成员函数

友元全局函数：

友元函数传入对象或引用，传引用效率更高，使用的时候直接传入对象的名称即可，如图：

友元成员函数：将一个类的成员函数声明为另一个类的友元：

使用方法，将Circle的printXY声明为Coordinate的友元，那么可以在Circle的printXY使用时可以使用Coordinate的私有数据成员了，友元的方便之处便在于此：

映射的截图

链表

特点：数据插入速度快

迭代器的使用

标准模板库

函数模板里的class表示的是数据类型