C++ 内联函数

函数模板

#include <iostream>


//函数模板，T代表的是一类类型
template <class T>
void swap(T &a,T &b)
{
    T tem;
    tem  =  a;
    a    =  b;
    b    = tem;
}
int main()
{
    int i1=100,i2=200;
    std::cout<<"交换前："<<"i1 = "<<i1<<",i2 = "<<i2<<std::endl;
    swap(i1,i2); //i1与i2为整型
    std::cout<<"交换后："<<"i1 = "<<i1<<",i2 = "<<i2<<std::endl;

    std::string    s1="Mike",s2="Lucy";

    std::cout<<"交换前："<<"s1 = "<<s1<<",s2 = "<<s2<<std::endl;
    swap(s1,s2); //i1与i2为整型
    std::cout<<"交换后："<<"s1 = "<<s1<<",s2 = "<<s2<<std::endl;
    return 0;
}
}

运行结果：

交换前：i1 = 100,i2 = 200
交换后：i1 = 200,i2 = 100
交换前：s1 = Mike,s2 = Lucy
交换后：s1 = Lucy,s2 = Mike

内联函数来源？
解决函数调用的效率问题。
特点：
有函数的结构，但编译后不具备函数的特点。编译时，类似于宏替换，用函数体替换调用处的函数名。
好处:不浪费调用时间，不调用栈。

类的模板使用内联的方式，声明和定义放在一起：

#include <iostream>
#include <string>
template <class T>
class Stack
{
public:
    Stack (unsigned int siz=100)
    {
        size = siz;
        data = new T[size];
        sp = 0;
    }
    ~Stack()
    {
        delete []data;
    }
    void push(T value)
    {
        data[sp++] = value;
    }
    T pop()
    {
        return data[--sp];
    }

private :
    unsigned int size;
    unsigned int sp;
    T *data;

};

int main()
{
    Stack<int> intstack(100);

    intstack.push(1);
    intstack.push(2);
    intstack.push(3);

    std::cout<<intstack.pop()<<"\n";
    std::cout<<intstack.pop()<<"\n";
    std::cout<<intstack.pop()<<"\n";

    return 0;
}