WhiteStruggle
WhiteStruggle

C++ 模板

函数模板

函数模板，是可以创建一个通用的函数，可以支持多种形参。

用关键字 template 来定义，

在函数模板中，数据的值和类型都被参数化了，发生函数调用时编译器会根据传入的实参来推演形参的值和类型。

template 
返回值 函数名（形参表列） 模板参数表
{
    // 函数体
}

第一行的template是一句声明语句

template 是定义模板函数的关键字

尖括号里可以有多个类型

用class(或者typename来定义)。

然后后面跟定义的函数模板，切记中间不可以加其他的语句，不然会报错！

#include 
#include 
using namespace std;

template 
void print(T);

int main()
{
    print(55);
    print('Y');
    print("Hello");
    system("pause");
    return 0;
}

template 
void print(T x)
{
    cout
        << x
        << endl;
}

函数模板也可以提前声明，不过声明时需要带上模板头，并且模板头和函数定义（声明）是一个不可分割的整体，它们可以换行，但中间不能有分号。

类模板

类的定义格式：

template class 类名{
    //TODO:
};

例：

template
class Student 
{
    // 成员变量  成员函数
};

在类外定义成员函数时仍然需要带上模板头

成员函数定义模板格式：

template
返回值类型 类名<类型参数1 , 类型参数2, ...>::函数名(形参列表){
    //TODO:
}

例：

template
void Student::say(){
};

构造函数 以及 析构函数 的模板 ，两者类似，析构函数只需要 多添加一个 ~ 符，且没有参数

template
类名<类型参数1 , 类型参数2, ...>::类名(形参列表) : 变量初始化{
    //TODO:
}

例：

// 构造函数
template
Student::Student(T1 a, T2 b) :m_a(a), m_b(b) {};

// 析构函数
template
Student::~Student() {
};

指针对象 注意事项：

  • 赋值号两边的数据类型必须一致
  • 赋值号右边需要指明数据类型
格式：
类名<类型参数1,类型参数2 ····> 对象名 = new 类名<类型参数1,类型参数2 ····>(初始化参数1，参数2 ·····);

例：
Student *Man = new Student("浑元形意太极门掌门人", "马保国");

#include 
#include 

using namespace std;
template
class Student 
{
private:
    T1 m_a;
    T2 m_b;
public:
    Student(T1 a, T2 b);
    void say();
    ~Student();
};
// 构造函数
template
Student::Student(T1 a, T2 b) :m_a(a), m_b(b) {};
// 成员函数
template
void Student::say(){
    cout << this->m_a << this->m_b << endl;
};
// 析构函数
template
Student::~Student() {
    cout << this->m_a << this->m_b << endl;
};

int main()
{
    Student Sir("浑元形意太极门掌门人","马保国");
    Sir.say();
    Student c(2,'B');
    c.say();
    Student *Man = new Student("练习两年半的偶像练习生", "坤坤");
    Man->say();
    delete Man;

    return 0;
}

结果：
浑元形意太极门掌门人马保国
2B
练习两年半的偶像练习生坤坤
练习两年半的偶像练习生坤坤
2B
浑元形意太极门掌门人马保国

类模板的静态成员

静态模板成员变量

static 数据类型 变量名;

初始化格式：
template
数据类型 类名<类型参数1 , 类型参数2, ...>::变量名 = 数据;

注意： 数据类型定义与初始化要一致

不使用模板定义静态变量：

static T1 count1;

// 模板静态成员变量初始化  
template
T1 Student::count1 = 0;

使用固定类型定义静态变量：

static int count2;

// 模板静态成员变量初始化
template
int Student::count2 = 0;

注意：

  • 静态成员变量，可以在类的内部使用，可以在外部进行操作

  • 静态成员变量使用模板定义时，当传入的模板类型不是可以操作的类型就会报错

原本希望传入的是整型，然后进行++操作

结果传入了string类型，由于不匹配所以会出现以下错误提示：

错误  C2676   二进制“++”:“T1”不定义该运算符或到预定义运算符可接收的类型的转换

#include 
#include 

using namespace std;

template
class Student
{
public:
    static T1 count;    // 计数
private:
    T1 m_a;
    T2 m_b;
public:
    Student(T1 a, T2 b);
    void say();
};

// 构造函数
template
Student::Student(T1 a, T2 b) :m_a(a), m_b(b) {
    //count++; //传入的类型T1 不为整数可操作类型，就会报错， C2676
};

// 成员函数
template
void Student::say() {
    cout  << ". " << this->m_a << this->m_b << endl;
    
    // 静态成员变量初始化之后，在类中使用时，会引发异常  此位置的异常 ： return (_CSTD strlen(_First));
    //cout << this->count << endl;
};

template
T1 Student::count = 0;// 仅初始化，不在类中使用，就不会出现问题，但也就好无意义了

int main()
{
    Student Sir("浑元形意太极门掌门人", "马保国");
    // 因为传入了string类型，count可以手动赋值来计数,但无法通过，会引发异常， 此位置的异常 ： return (_CSTD strlen(_First));
    // Sir.count = "1";
    Sir.say();
    return 0;
}

引起一系列问题的原因可能为：

1. 设置的类型初始化问题
    不能匹配确定是否合理初始化
    
2. 设置类型与想要操作的类型不匹配
    希望使用 ++等一些列运算符 操作的 整数或浮点数类型
    时间类型为 string

传入类型合理类型，修改上例的相关区域：

// 构造函数
template
Student::Student(T1 a, T2 b) :m_a(a), m_b(b) {
    count++; 
};
// 成员函数
template
void Student::say() {
    cout << ". " << this->m_a << this->m_b << endl;
    cout << this->count << endl;
};

// 初始化
template
T1 Student::count = 0;


// 创建对象
Student Sir(2,"B" );
Sir.count++;
Sir.say();


结果：
. 2B
2

因此解决此类问题，就可以为static类型变量，创建 特定的构造函数 以及 模板

#include 
#include 

using namespace std;

// T3专门用来给静态变量传递模板数据类型
template
class Student
{
public:
    static T3 count;   // 计数
private:
    T1 m_a;
    T2 m_b;
public:
    Student(T1 a, T2 b);
    void say();
};

// 构造函数，可以设置空的构造函数，之后通过接口传值，此处就省略
template
Student::Student(T1 a, T2 b) :m_a(a), m_b(b) {
    count++;
};
// 成员函数
template
void Student::say() {
    cout << this->count  << ". " << this->m_a << this->m_b << endl;
};

// 静态成员变量的初始化
template
T3 Student::count = 0;

int main()
{
    Student Sir("浑元形意太极门掌门人", "马保国");
    Sir.say();

    Student *Man = new Student("练习两年半的偶像练习生", "坤坤");
    Man->say();
    delete Man;

    Student c(2, 'B');
    c.say();    
    Student l(3, 'B');
    l.say();    
    Student s(6, 'B');
    s.say();
    return 0;
}

结果：
1-1. 浑元形意太极门掌门人马保国
2-2. 练习两年半的偶像练习生坤坤
1-1. 2B
2-2. 3B
3-3. 6B
  • 通过静态变量可以知道，每次类的模板不同，就会产生新的类，且不互通

上例产生了两个类的格式

  • Student
  • Student

类模板与友元函数

// 模板类
template
class Student
{
private:
    T m_x;
    T m_y;
public:
// 构造函数
    Student(T x, T y) :m_x(x), m_y(y) {};
// 友元函数
    friend T sum(Student s);
};

// 函数模板
template
T sum(Student s)
{
    return s.m_x + s.m_y;
}

严重性 代码  说明  项目  文件  行   禁止显示状态
错误  LNK2019 无法解析的外部符号 "class std::basic_string,class std::allocator > __cdecl sum(class Student,class std::allocator > >)" (?sum@@YA?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@V?$Student@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@@@Z)，该符号在函数 "void __cdecl Study(void)" (?Study@@YAXXZ) 中被引用 学习  E:\C++\学习\学习\Study.obj  1

类模板 不能 引入函数模板，虽然程序没有错误，但是在编译时就会出错

友元函数 需要指明 具体的参数类型 ，可以通过 重载 去定义多个 友元函数

注意: 友元函数 无法直接 访问类模板的参数，需要传递 类的对象 或 对象指针

#include 
#include 

using namespace std;

// 模板类
template
class Student
{
private:
    T m_x;
    T m_y;
public:
// 构造函数
    Student(T x, T y) :m_x(x), m_y(y) {};
// 友元函数的声明
    friend string sum(Student s);
    friend int sum(Student s);
};

// 友元函数的定义
string sum(Student s)
{
    return s.m_x + s.m_y;
}
int sum(Student s)
{
    return s.m_x + s.m_y;
}

int main()
{
    Student Sir("浑圆形意太极门掌门人", "马保国");
    cout << sum(Sir) << endl;
    
    Student Age(6,9);
    cout << sum(Age) << endl;
    return 0;
}

类模板与 友元 类的成员函数

friend 表示 出现 friend 的类

member 表示 成员函数的类

定义的一般顺序：

第一步：
class friend;

第二步：
template 
class member{
    // 成员变量 ， 成员函数
    // 需要 友元的成员函数 声明
}

第三步：
class friend{
    // 成员变量 ， 成员函数
    // friend member类的 友元成员函数
}

第四步：
member类的 友元成员函数 的实现

例子：

#include 
#include 

using namespace std;

template
class Student;      // 同样很有必要的声明


// 第一个类， member类
class Introduct
{
public:
    // 成员函数
    string sum(Student* s); // 对象指针
    int sum(Student s);        // 对象
};

// 第二个类，友元类
template
class Student
{
private:
    T m_x;
    T m_y;
public:
// 构造函数
    Student(T x, T y) :m_x(x), m_y(y) {};
// 友元函数的声明
    friend string Introduct::sum(Student* s);
    friend int Introduct::sum(Student s);
};


// 友元函数的定义
string Introduct::sum(Student* s)
{
    return s->m_x + s->m_y;
}
int Introduct::sum(Student s)
{
    return s.m_x + s.m_y;
}


int main()
{
    Introduct Mk;

    Student Sir("浑圆形意太极门掌门人", "马保国");
    cout << Mk.sum(&Sir) << endl;

    Student Age(6,9);
    cout << Mk.sum(Age) << endl;
    return 0;
}

结果：
浑圆形意太极门掌门人马保国
15

通过 重载 来扩展， member类的使用

同样需要传递 实例对象 或 实例对象指针，访问类的成员

类模板与 友元 模板类的成员函数

两个类模板之间

  1. 提前声明 member类
  2. 定义 friend类， 引入友元的成员函数
  3. 定义 member类
  4. 定义 模板成员函数
#include 
#include 

using namespace std;

template
class Introduct;        // 有必要的提前定义

// 第一个类， 友元类
template
class Student
{
private:
    T m_x;
    T m_y;
public:
    Student(T x, T y) :m_x(x), m_y(y) {};
    // 友元类
    friend T Introduct::sum(Student s);
};


// 第二个类， member类
template
class Introduct
{
public:
    // 成员函数
    S sum(Student s);
};

// 模板成员函数
template
S Introduct::sum(Student s)
{
    return s.m_x + s.m_y;
}

int main()
{
    Introduct Mk;
    Student Sir("浑圆形意太极门掌门人", "马保国");
    cout << Mk.sum(Sir) << endl;

    Introduct M;
    Student Age(6, 9);
    cout << M.sum(Age) << endl;
    return 0;
}

注意：
在使用模板时，前后要对应

类模板 与 友元 类

优先定义 友元类

#include 
#include 

using namespace std;

// 第一个类， 友元类
template
class Student
{
private:
    T m_x;
    T m_y;
public:
    Student(T x, T y) :m_x(x), m_y(y) {};
    // 友元类
    friend class Introduct;
};


// 第二个类， member类
class Introduct
{
public:
    // 成员函数
    string sum(Student* s); // 对象指针
    int sum(Student s);        // 对象
};

// Introduct成员函数
string Introduct::sum(Student* s)
{
    return s->m_x + s->m_y;
}
int Introduct::sum(Student s)
{
    return s.m_x + s.m_y;
}

int main()
{
    
    Introduct Mk;

    Student Sir("浑圆形意太极门掌门人", "马保国");
    cout << Mk.sum(&Sir) << endl;

    Student Age(6,9);
    cout << Mk.sum(Age) << endl;
    return 0;
}

结果：
浑圆形意太极门掌门人马保国
15

类模板 与 友元类 和 类模板与 类的友元成员函数 类似，不同点就是前者无需过多声明 成员函数，后者需要依次 声明 需要用到的 成员函数

类模板 与 友元 类模板

两个 类模板

  1. 提前声明 member类
  2. 定义 friend类 ， 引入 友元类
  3. 定义 member类
  4. 定义 模板成员函数
#include 
#include 

using namespace std;

template
class Introduct;        // 很有必要的声明

// 第一个类， 友元类
template
class Student
{
private:
    T m_x;
    T m_y;
public:
    Student(T x, T y) :m_x(x), m_y(y) {};
    // 友元类
    friend class Introduct;
};


// 第二个类， member类
template
class Introduct
{
public:
    // 成员函数
    S sum(Student s);
};

template
S Introduct::sum(Student s)
{
    return s.m_x + s.m_y;
}


int main()
{
    
    Introduct Mk;
    Student Sir("浑圆形意太极门掌门人", "马保国");
    cout << Mk.sum(Sir) << endl;

    Introduct M;
    Student Age(6, 9);
    cout << M.sum(Age) << endl;
    
    return 0;
}

结果：
浑圆形意太极门掌门人马保国
15

类模板与非类型参数

在定义模板的时候，可以引入参数

不能使用 结构体 、string 等定义非类型参数

template 

例如：
template 
class Student
{
}

在传递参数时，需要传递相对应的数据类型的数据
Student Sir;

例如：

#include 
#include 

using namespace std;

// 模板类
template
class Student
{
private:
    T m_n;
public:
    // 构造函数
    Student(T n) :m_n(n){};
    T say()
    {
        m_n += count;
        return m_n;
    }
};

// 

void Study()
{
    Student Sir(1);
    cout << Sir.say() << endl;
    cout << Sir.say() << endl;
    cout << Sir.say() << endl;
    cout << Sir.say() << endl;
}

结果：
3
5
7
9

类模板的继承

基类模板 与 子类

#include 
#include 

using namespace std;

// 基类
template 
class People
{
public:
    T m_num;
public:
    // 构造函数
    People(T num) : m_num(num) {};
    // 成员变量
    void show()
    {
        cout << "num = " << this->m_num << endl;
    }
};

// 子类
class Student : public People {
private:
    int m_code;
public:
    // 构造函数
    Student(int code, int num) :m_code(code), People(num) {};
    // 成员变量
    void show()
    {
        cout << "code = " << this->m_code << ";"
             << "num = " << this->m_num << endl;
    }
};


int main()
{
    People sir_1(10);
    sir_1.show();

    Student sir_2(996, 777);
    sir_2.show();
    
    return 0;
}

结果：
num = 10
code = 996;num = 777

基类模板 与 子类模板

#include 
#include 

using namespace std;

// 基类
template 
class People
{
public:
    T m_num;
public:
    // 构造函数
    People(T num) : m_num(num) {};
    // 成员变量
    void show()
    {
        cout << "num = " << this->m_num << endl;
    }
};

// 派生类
template 
class Student : public People {
private:
    S m_code;
public:
    // 构造函数
    Student(S code, S num) :m_code(code), People(num) {};
    // 成员变量
    void show()
    {
        cout << "code = " << this->m_code << ";"
             << "num = " << this->m_num << endl;
    }
};


int main()
{
    People sir_1(10);
    sir_1.show();

    Student sir_2(996, 777);
    sir_2.show();
    
    return 0;
}

结果：
num = 10
code = 996;num = 777

注意：构造函数，基类要指明类型，继承是也要指明类型，且前后照应

模板实参推断

从函数实参来确定模板实参的过程被称为模板实参推断(template argument deduction)

使用函数模板显示实参，可以覆盖实参推断机制

#include 
#include 

using namespace std;

template
int max(T1 a, T2 b)
{
    cout
        << "T1 = " << sizeof(T1) << endl
        << "T2 = " << sizeof(T2) << endl;
        
    if (a > b) return a;
    else if (a == b) return 0;
    else return b;
}

int main()
{
    short sh = 6;
    
    // 系统推断
    cout << max(sh, 3) << endl; 
    // 显式定义
    cout << max(sh, 3) << endl; 
    cout << max(sh, 3) << endl;
    return 0;
}

结果：
T1 = 4
T2 = 2
6
T1 = 4
T2 = 2
6
T1 = 4
T2 = 4
6

模板实例化

模板实例化是生成采用特定模板参数组合的具体类或函数（实例）

编译器生成一个采用 Array 的类，另外生成一个采用 Array 的类。通过用模板参数替换模板类定义中的模板参数，可以定义这些新的类。

隐式实例化

隐式实例化：通过编译器自己推测判断要实例化的类型。

编译器会根据实参推断类型

显式实例化

模板显式实例化(extern template)可以用来确保模板只被编译器实例化一次

  • 使用模板生成的编译单元不会重复实例化，会加快编译速度，并减小编译单元的尺寸

要显式实例化模板函数，在 template 关键字后接函数的声明（不是定义），且函数标识符后接模板参数。

template 返回值类型 函数名 <数据类型>

例如：
template
T1 max(T1 a, T2 b)
{
    if (a > b) return a;
    else if (a == b) return 0;
    else return b;
}

template int max(int a, int b);  //显式实例化，只需声明

模板类的显式实例化

template class 类名<数据类型>

例如：
template
class Student
{
private:
    T m_x;
    T m_y;
public:
    Student(T x,T y) :m_x(x), m_y(y) {};
    void prin()
    {
        cout << m_x << m_y << endl;
    }
};

// 显式实例化 类模板
template class Student;
template class Student;

模板类静态数据成员的显式实例

template 返回值类型 类名<数据类型>::函数名(参数列表);

例如：
template
class Student
{
private:
    T m_x;
    T m_y;
public:
    Student(T x,T y) :m_x(x), m_y(y) {};
    T sum(T a);
};

template
T Student::sum(T a)
{
    return this->m_x + this->m_y + a;
}

// 显式实例化 类模板
template string Student::sum(string a);
template int Student::sum(int a);

注意：类型的规范，使用相同模板在带入数据类型时，也要同步，不要随心所欲，想使用不同类型就分开定义，一句话：早知现在何必当初

模板显式具体化

让模板能够针对某种具体的类型使用不同的算法（函数体或类体不同），称为模板的显示具体化（Explicit Specialization）

利用对函数模板的显式具体化，对于 数组 和 结构体 数据类型进行操作

C++98标准 : 原型和定义以 template<> 开头，并通过名称指出类型。函数调用优先级是 非模板函数 > 具体化模板函数 > 常规模板函数。

在函数模板 或 类模板 的基础上，新添加一个专门针对 特定类型 的、实现方式不同 的 具体化 函数或类

模板函数显式具体化

template<> 
数据类型 函数名<复杂数据类型>(参数列表){
    // 函数体
}

例如：
template 
T stripling(T a, T b)
{
    return a < b ? a : b;
};

// 只有定力了原型模板，才能定义如下的显式具体化，原型模板如上 template  T stripling(T a, T b)
// People 为定义的结构体类型
template <>
People stripling(People a, People b)
{
    return a.age < b.age ? a : b;
};

#include 
#include 

using namespace std;

typedef struct{
    string name;
    int age;
}People;

// 输出 较大值
template 
T stripling(T a, T b)
{
    return a < b ? a : b;
};

// 需要有原型，如上 template  T stripling(T a, T b)
template <>
People stripling(People a, People b)
{
    return a.age < b.age ? a : b;
};

void prin(People sir)
{
    cout << sir.name << "," << sir.age << "岁，不讲武德" << endl;
}

int main()
{
    People young1 = { "八十公斤的年轻人",35 };
    People young2 = { "九十公斤的年轻人",30 };
    People leader = { "马保国",69 };
    prin(stripling(young1,leader));
    prin(stripling(young2,leader));
    return 0;
}

模板类的显式具体化

在类模板的具体化中,成员方法的实例化是不能带模板头template<>的。

template<>
class 类名<复杂数据类型>
{
    // 成员变量
    // 成员函数
}

例如：
template 
class People {
    // 成员变量 成员函数
}

// msg 为 结构体
template<>
class People
{
    // 成员变量 成员函数
}

#include 
#include 

using namespace std;

template 
class People
{
private:
// 成员变量
    T1 m_x;
    T2 m_y;
public:
// 构造函数
    People(T1 x, T2 y) :m_x(x), m_y(y) {};
// 成员函数
    void show();
};

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

// 类模板显式具体化(针对 结构体 的显式具体化)
typedef struct
{
    string name;
    int age;
} msg ;

template<>
class People
{
private:
// 成员变量
    msg m_leader;
    msg m_young;
public:
// 构造函数
    People(msg leader,msg young) :m_leader(leader), m_young(young){};
// 成员函数
    void show();
};

// 注意！这里不能带模板头template<>
void People::show()
{
// 判断 年轻人 与 掌门人 年龄
    msg stripling = this->m_leader.age > this->m_young.age ? m_leader : m_young;
// 输出年龄大的老同志
    cout << stripling.name << ":" << stripling.age << endl << "马家功夫名不虚传" << endl;
}


int main()
{
    People Sir("浑圆形意太极门掌门人","马保国");
    Sir.show();

    msg young = { "八十公斤的年轻人",35 };
    msg leader = { "马保国",69 };
    People Man(leader,young);
    Man.show();
    return 0;
}

结果：
浑圆形意太极门掌门人,马保国
马保国:69
马家功夫名不虚传

部分显式具体化

部分显式具体化只能用于类模板，不能用于函数模板

template
class 类名<复杂数据类型 , 模板类型>         // 模板类型 要 对应，位置不固定，根据情况而定
{
    // 成员变量
    // 成员函数
}

例如：
template 
class People {
    // 成员变量 成员函数
}

// msg 为 结构体
template
class People
{
    // 成员变量 成员函数
}

#include 
#include 

using namespace std;

template 
class People
{
private:
// 成员变量
    T1 m_x;
    T2 m_y;
public:
// 构造函数
    People(T1 x, T2 y) :m_x(x), m_y(y) {};
// 成员函数
    void show();
};

template 
void People::show()
{
// 输出数据
    cout << m_x << "," << m_y << endl;
}

// 部分显式具体化(针对 结构体 的部分显式具体化)
typedef struct
{
    string name;
    int age;
}msg;

template
class People
{
private:
// 成员变量
    msg m_leader;
    T m_sure_age;
public:
// 构造函数
    People(msg leader,T sure_age) :m_leader(leader), m_sure_age(sure_age){};
// 成员函数
    void show();
};

// 注意！需要带模板头
template
void People::show()
{
// 修改数据，并输出
    this->m_leader.age = this->m_sure_age;
    cout << this->m_leader.name << ":" << this->m_leader.age << endl << "马家功夫名不虚传" << endl;
}


int main()
{
    People Sir("浑圆形意太极门掌门人","马保国");
    Sir.show();

    msg leader = { "马保国",35 };
    People Man(leader,69);
    Man.show();
    
    return 0;
}

结果：
浑圆形意太极门掌门人,马保国
马保国:69
马家功夫名不虚传

模板 用于多文件编程

在将函数用于多文件编程时，我们通常是将 函数定义 放在 源文件(.cpp 文件) 中，将 函数声明 放在 头文件（.h文件）中，使用函数时 引入（#include 命令） 对应的 头文件 即可

编译是针对单个源文件的，只要有函数声明，编译器就能知道函数调用是否正确；而将函数调用和函数定义对应起来的过程，可以延迟到链接时期。正是有了连接器的存在，函数声明和函数定义的分离才得以实现。

模板并不是真正的函数或类，它仅仅是用来生成函数或类的一张 “图纸”，在这个生成过程中有三点需要明确：

  • 模板的实例化是按需进行的，用到哪个类型就生成针对哪个类型的函数或类，不会提前生成过多的代码
  • 模板的实例化是由编译器完成的，而不是由链接器完成的
  • 在实例化过程中需要知道模板的所有细节，包含声明和定义（只有一个声明是不够的，可能会在链接阶段才发现错误）

头文件：s.h ，存放类模板的定义

#ifndef s
#define s

template
class Student
{
private:
    T m_x;
    T m_y;
public:
    Student(T x, T y) :m_x(x), m_y(y) {};
    T sum();
};

#endif

cpp文件，定义类的成员函数

#include 
#include 
#include "s.h"

using namespace std;

template
T Student::sum()
{
    return this->m_x + this->m_y ;
}

main函数调用

#include "s.h"
#include 
#include 
using namespace std;
int main()
{
    Student Sir(1, 3);
    cout << Sir.sum() << endl;

    system("pause");
    return 0;
}

直接就报错

严重性 代码  说明  项目  文件  行   禁止显示状态
错误  LNK2019 无法解析的外部符号 "public: int __thiscall Student::sum(void)" (?sum@?$Student@H@@QAEHXZ)，该符号在函数 _main 中被引用 学习  E:\C++\学习\学习\学习.obj 1   

错误  LNK1120 1 个无法解析的外部命令    学习  E:\C++\学习\Debug\学习.exe  1

但如果将 类的成员函数 定义放到 头文件：s.h ，这些错误就没有了

不能将模板的声明和定义分散到多个文件中的根本原因是：模板的实例化是由编译器完成的，而不是由链接器完成的，这可能会导致在链接期间找不到对应的模板实例。

参考：

  1. 将 C++ 模板应用于多文件编程

由于参考内容过多，在这里就不一一列举，如若有问题，请联系我，会及时修改，添加！！！

你可能感兴趣的:(C++ 模板)

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
  • c++中如何判断变量的数据类型，并输出 xnrbjy c++开发语言
    C++中如果想要判断变量的数据类型，可以使用typeid运算符。该运算符返回一个std::type_info类型的对象，可以使用name()方法获取其名称从而确定变量的类型，例如：#include#includeusingnamespacestd;intmain(){inta=123;floatb=3.14;boolc=true;chard='A';stringe="HelloWorld";cou
  • C++学习笔记（lambda函数） __TAT__ C&C++c++学习笔记
    C++learningnote1、lambda函数的语法2、lambda函数的几种用法1、lambda函数的语法lambda函数的一般语法如下：[capture_clause](parameters)->return_type{function_body}capture_clause：需要捕获的变量，但要求该变量必须在这个作用域中。通常的捕获方式有以下几种：[]：不捕获任何变量[&]：按引用捕获变
  • ES-LTR粗排模块 poins jenkins运维
    ES-LTR粗排模块官方资源：https://github.com/HeiBoWang/elasticsearch-learning-to-rankElasticsearch学习排名插件使用机器学习提高搜索相关性排名。它为维基媒体基金会和Snagajob等地方的搜索提供了动力！这个插件有什么功能此插件：允许您在Elasticsearch中存储特征（Elasticsearch查询模板）记录特征得分（
  • C++ pdf 打印 插入图片 灿烂李 java前端服务器
    一：使用PODOFO给PDF插入图片：#includeintmain(){PoDoFo::PdfMemDocumentpdfDocument;PoDoFo::PdfPage*page;PoDoFo::PdfImageimage;PoDoFo::PdfVecObjects*vec_objects;PoDoFo::PdfRectrect;//打开PDF文档pdfDocument.loadFromFil
  • k8s入门到实战（十）—— CronJob详细介绍及使用示例 一弓虽 k8s学习kubernetes容器云原生
    CronJob什么是CronJob在k8s中，CronJob是一种用于定期执行任务的资源对象。它基于Cron表达式，允许您在指定的时间间隔内自动运行容器化的任务。CronJob可以定义以下属性：schedule：指定任务执行的时间表，使用标准的Cron表达式语法。例如，“0****”表示每小时执行一次任务。jobTemplate：定义要执行的任务的模板，通常是一个Pod模板。这个模板包含了任务所需
  • 《外观模式（极简c++）》 Bovinitwo 设计模式（极简c++版）c++开发语言
    本文章属于专栏-概述-《设计模式（极简c++版）》-CSDN博客模式说明方案：外观模式提供了一个统一的接口，简化了一组复杂子系统的访问方式。优点：将客户端与子系统解耦，降低了复杂性。提高了代码的灵活性和可维护性。缺点：可能导致外观类过于庞大，承担了过多的责任。增加了系统的抽象层，有时会影响性能。本质思想：外观模式的本质思想是为一组复杂的子系统提供一个简单的接口，隐藏其复杂性，使得客户端可以更轻松地
  • OpenCV（一个C++人工智能领域重要开源基础库） 简介 愚梦者 OpenCV人工智能人工智能opencvc++图像处理计算机视觉开源
    返回：OpenCV系列文章目录（持续更新中......）上一篇：OpenCV4.9.0配置选项参考下一篇：OpenCV4.9.0开源计算机视觉库安装概述引言：OpenCV（全称OpenSourceComputerVisionLibrary）是一个基于开放源代码发行的跨平台计算机视觉库，可以用来进行图像处理、计算机视觉和机器学习等领域的开发。该库由英特尔公司于1999年开始开发，最初是为了加速处理器
  • 动态多态的注意事项 Austin_1024 动态多态静态多态虚函数子类重写父类虚函数实现动态多态
    大家好：衷心希望各位点赞。您的问题请留在评论区，我会及时回答。多态的基本概念多态是C++面向对象三大特性之一（多态、继承、封装）多态分为两类：静态多态：函数重载和运算符重载属于静态多态，复用函数名。动态多态：通过派生类和虚函数实现运行时多态。静态多态和动态多态的区别：静态多态的函数地址早绑定——编译阶段确定函数地址。动态多态的函数地址晚绑定——运行阶段确定函数地址。下面通过案例讲解多态：#incl
  • C/C++中的Static关键字 SuhyOvO C语言C++c语言c++
    Static关键字在C和C++编程中是不可或缺的一部分，它用于定义具有持久存储期的变量和函数，以及类的静态成员。虽然它的使用相对直接，但不恰当的使用可能会导致难以调试的错误和混淆。本文将探讨static关键字的概念、作用以及在C和C++中的具体应用。文章目录第一部分：深入理解Static关键字定义和基本概念在C和C++中static的基本作用第二部分：Static在C语言中的使用静态全局变量静态局
  • C++进阶学习（3）类类型转换 一只特立独行猪 C++的学习c++学习
    文章目录一、类类型转换1.构造函数构造2.类型转换函数一、类类型转换数据类型转换在程序编译时或在程序运行实现基本类型←→基本类型基本类型←→类类型类类型←→类类型类对象的类型转换可由两种方式说明：构造函数转换函数称为用户定义的类型转换或类类型转换，有隐式调用和显式调用方式1.构造函数构造当类ClassX具有以下形式的构造函数：说明了一种从参数arg的类型到该类类型的转换ClassX::ClassX
  • C++ 如何去认识模板 SuhyOvO C++c++开发语言
    引言:C++模板是泛型编程的基石,允许程序员定义可与任何数据类型协作的函数和类。这种机制极大地增加了代码的灵活性和复用性,是C++最强大的特性之一。本文将深入探讨C++模板的概念、优势以及使用方法,帮助读者掌握这一重要的编程工具。文章目录模板简介模板的优势一、模板基础1.1模板的概念1.2函数模板1.3类模板二、模板进阶2.1模板的实例化2.2模板的特化2.3模板的默认参数2.4模板的嵌套三、模板
  • C++面试题 虾仁A 面试c++
    目录一、堆和栈的区别二、C++中new、delte和malloc的区别三、什么是源对象四、C++有哪些设计模式五，你使用过C++哪些类型的指针一、堆和栈的区别特性堆栈申请方式由程序员显式申请和释放由系统自动分配和释放分配方式动态分配自动分配分配效率相对较慢，需要遍历内存链表寻找合适空间相对较快，系统直接分配内存地址不连续的内存区域连续的内存区域大小限制大小灵活，上限取决于虚拟内存大小固定，通常较小
  • 15届蓝桥杯备赛(3) sad_liu #sad_liu的刷题记录蓝桥杯职场和发展
    文章目录15届蓝桥杯备赛(3)回溯算法组合组合总和III电话号码的字母组合组合总和组合总和II分割回文串子集子集II非递减子序列全排列全排列II贪心算法分发饼干最大子数组和买股票的最佳时机II跳跃游戏15届蓝桥杯备赛(3)提高C++程序的输入输出效率，尤其是在需要大量输入输出操作时。ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie
  • Vue：为什么要使用v-cloak 刻刻帝的海角 vue.js前端javascript
    Vue.js是一种流行的JavaScript框架，它使我们能够构建交互性强大的用户界面。在Vue.js中，v-cloak是一个指令，用于解决在页面加载时出现的闪烁问题。本文将介绍如何使用v-cloak及代码来优化Vue.js应用程序的渲染效果。引言当我们使用Vue.js构建应用程序时，有时会遇到一个问题：在页面加载时，由于Vue.js需要一定的时间来解析和渲染模板，会导致页面上显示出未经处理的Mu
  • C++ primer 第十二章 红鼻子怡宝 c++primerc++开发语言
    动态分配的对象的生存期与它们在哪里创建无关，只有当显式地被释放时，这些对象才会销毁。静态内存用来保存局部static对象、类static数据成员以及定义在任何函数之外的变量。栈内存用来保存定义在函数内的非static对象。堆内存用来存储动态分配的对象。静态或栈内存中的对象由编译器自动创建和销毁，而堆内存中的对象必须显式地销毁它们。1.动态内存与智能指针运算符new在动态内存中为对象分配空间并返回一
  • 5. C++ 局部静态变量在什么时候分配内存和初始化？ 九五一 C++知识c++javajvm开发语言数据结构
    C++局部静态变量在什么时候分配内存和初始化？对于C语言的全局和静态变量，不管是否被初始化，其内存空间都是全局的；如果初始化，那么初始化发生在任何代码执行之前，属于编译期初始化。由于内置变量无须资源释放操作，仅需要回收内存空间，因此程序结束后全局内存空间被一起回收，不存在变量依赖问题，没有任何代码会再被执行！C++引入了对象，这给全局变量的管理带领新的麻烦。C++的对象必须有构造函数生成，并最终执
  • win7休眠、待机api WarmSword Windowsapiwindows休眠待机关机
    win7休眠、待机api通过c++让windows进入休眠或者待机状态。xp、win7下用SetSystemPowerState函数，vista及之后的版本使用SetSuspendState函数。xp、win7:SetSystemPowerStateBOOLWINAPISetSystemPowerState(_In_BOOLfSuspend,_In_BOOLfForce);ParametersfS
  • 【No.15】蓝桥杯动态规划上|最少硬币问题|0/1背包问题|小明的背包1|空间优化滚动数组(C++) ChoSeitaku 蓝桥杯备考蓝桥杯动态规划c++
    DP初步：状态转移与递推最少硬币问题有多个不同面值的硬币(任意面值)数量不限输入金额S，输出最少硬币组合。回顾用贪心求解硬币问题硬币面值1、2、5。支付13元，要求硬币数量最少贪心:(1)5元硬币，2个(2)2元硬币，1个(3)1元硬币，1个硬币面值1、2、4、5、6.，支付9元。贪心:(1)6元硬币，1个(2)2元硬币，1个(3)1元硬币，1个错误!答案是:5元硬币+4元硬币=2个硬币问题的正解
  • 游戏客户客户端面经 Unity游戏开发 游戏游戏开发求职程序员
    C#和C++的类的区别C#List添加100个Obj和100int内存是怎么变化的重载和重写的区别，重载是怎么实现的重写是怎么实现的？虚函数表是类的还是对象的用过哪些C++的STLVector底层是怎么实现的Vector添加一百次数据内存是怎么变化Map的底层，红黑树的查询和插入的时间复杂程度，Unordermap的底层实现是什么List的底层是怎么实现的场景里面有6个玩家扮演贪吃蛇进行3v3，场
  • P5963 [BalticOI ?] Card 卡牌游戏 贪心 golemon. 算法题游戏算法
    [P5963BalticOI?]Card卡牌游戏【来源请求】-洛谷|计算机科学教育新生态(luogu.com.cn)贪心模板题。存在(x1,y1)(x_1,y_1)(x1,y1)，(x2,y2)(x_2,y_2)(x2,y2)，假设xi>yix_i>y_ixi>yi，显然得认为：−x1+y2-x_1+y_2−x1+y2是最优得的，那么有：−x1+y2≤−x2+y1-x_1+y_2\le-x_2+y
  • C++中，#define和const有什么区别？ / 静态链接和动态链接有什么区别？ Layla_c C语言C++c++前端jvm
    一、C++中，#define和const有什么区别？C++中，#define和const都用于定义常量，但它们在用法和特性上存在显著的区别。定义与用途：#define是C++预处理器的指令，用于定义宏。宏可以是函数、对象、类型等，它的作用是在预处理阶段对代码进行文本替换。const是C++的关键字，用于定义常量。这些常量在编译阶段生效，并带有数据类型。const定义的常量必须在声明时初始化。编译器
  • c++类和结构体 JINbigXIA c++算法
    众所周知c++是c的高级版本在面向对象上就有了体现c++有一个多的内容就是类，那么我们来看看如何创建类还要类和结构体之间的区别classplayer{public:intx;inty;charname[10];intage;voidadd(intx,inty){std::cout<
  • C++中using namespace std的作用以及vector数组的使用 宁77吖 数据结构c++学习开发语言
    C++中usingnamespacestd的作用以及vector数组的使用本文为自我学习记录，主要包括C++中usingnamespacestd的作用vector数组的使用文章目录C++中usingnamespacestd的作用以及vector数组的使用一、usingnamespacestd二、vector数组2.1使用vector>和ints[][]定义二维数组区别2.2vector数组的插入，
  • c# 与c++类型对应关系 让您看见未来 c++c#c#开发语言
    c#c++ubytecharshortshortint32int32_tlongint64_tfloatfloatdoubledoubleIntPt,[]void*
  • 【C++】学习记录--Thread线程库的使用 KK虫 c++
    线程是进程的一个执行路径，是CPU调度与分配的的最小单元。创建线程需要一个可调用的函数或者函数对象作为线程的入口。C++11中可以通过函数指针/函数对象或者lambda表达式实现。基本语法#includethreadt(function_name,args...)'function_name'为程序入口点'args'为传递给函数的参数线程创建后，可以使用't.join*()'等待线程完成，或使用'
  • GB28181 —— 4、C++编写GB28181设备端，完成将.h264文件读取转发至GB28181服务并可播放（附源码） 信必诺 GB28181GB28181eXosip2Qth264
    效果 源码说明     主要功能模拟设备端，完成注册、注销、心跳等，完成读取.h264文件实时转ps格式后封包rtp进行推送给服务端播放。 源码/****@remark:ps头的封装,里面的具体数据的填写已经占位，可以参考标准*@param:pData[in]填充ps头数据的地址*s64Src[in]时间戳*@return:0success,othersfailed*/intgb28181_mak
  • 第十五届蓝桥杯软件赛模拟赛第三期（c++，python，java通用） 北洋的霞洛 蓝桥杯历年真题蓝桥杯c++算法
    注：1.填空题用最简单的方式（暴力递归或枚举）得出答案即可。2.编程题若无思路可用暴力递归或枚举也能拿到不少的分数。第一题【问题描述】请问2023有多少个约数？即有多少个正整数，使得2023是这个正整数的整数倍。【答案提交】这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。【思路】简单模拟【代码】#includeusing
  • CSE101 C++ Introduction to Data Structures and Algorithms zhuyu0206girl c++开发语言
    CSE101IntroductiontoDataStructuresandAlgorithmsProgrammingAssignment5Inthisprojectyouwillcreateanew,andsomewhatdifferentintegerListADT,thistimeinC++.YouwillusethisListtoperformshufflingoperations,andd
  • 突破编程_C++_C++11新特性（type_traits的概念以及核心类型特性） breakthrough_01 c++开发语言
    1type_traits的概述type_traits是C++标准模板库（STL）中的一个头文件，它定义了一系列模板类，这些模板类在编译期获取某一参数、某一变量、某一个类等的类型信息，主要用于进行静态检查。通过使用type_traits，程序员可以在编译时就获得关于类型的详细信息，从而可以在不实际运行程序的情况下进行类型相关的优化和检查。type_traits中的内容主要可以分为以下几类：辅助基类：
  • 书其实只有三类 西蜀石兰 类
    一个人一辈子其实只读三种书，知识类、技能类、修心类。 知识类的书可以让我们活得更明白。类似十万个为什么这种书籍，我一直不太乐意去读，因为单纯的知识是没法做事的，就像知道地球转速是多少一样（我肯定不知道），这种所谓的知识，除非用到，普通人掌握了完全是一种负担，维基百科能找到的东西，为什么去记忆？ 知识类的书，每个方面都涉及些，让自己显得不那么没文化，仅此而已。社会认为的学识渊博，肯定不是站在
  • 《TCP/IP 详解，卷1：协议》学习笔记、吐槽及其他 bylijinnan tcp
    《TCP/IP 详解，卷1：协议》是经典，但不适合初学者。它更像是一本字典，适合学过网络的人温习和查阅一些记不清的概念。 这本书，我看的版本是机械工业出版社、范建华等译的。这本书在我看来，翻译得一般，甚至有明显的错误。如果英文熟练，看原版更好： http://pcvr.nl/tcpip/ 下面是我的一些笔记，包括我看书时有疑问的地方，也有对该书的吐槽，有不对的地方请指正： 1.
  • Linux—— 静态IP跟动态IP设置 eksliang linuxIP
    一.在终端输入 vi /etc/sysconfig/network-scripts/ifcfg-eth0 静态ip模板如下： DEVICE="eth0" #网卡名称 BOOTPROTO="static" #静态IP（必须） HWADDR="00:0C:29:B5:65:CA" #网卡mac地址 IPV6INIT=&q
  • Informatica update strategy transformation 18289753290
    更新策略组件： 标记你的数据进入target里面做什么操作，一般会和lookup配合使用，有时候用0,1,1代表 forward  rejected rows被选中，rejected row是输出在错误文件里，不想看到reject输出，将错误输出到文件，因为有时候数据库原因导致某些column不能update，reject就会output到错误文件里面供查看，在workflow的
  • 使用Scrapy时出现虽然队列里有很多Request但是却不下载，造成假死状态 酷的飞上天空 request
    现象就是： 程序运行一段时间，可能是几十分钟或者几个小时，然后后台日志里面就不出现下载页面的信息，一直显示上一分钟抓取了0个网页的信息。 刚开始已经猜到是某些下载线程没有正常执行回调方法引起程序一直以为线程还未下载完成，但是水平有限研究源码未果。 经过不停的google终于发现一个有价值的信息，是给twisted提出的一个bugfix 连接地址如下http://twistedmatrix.
  • 利用预测分析技术来进行辅助医疗 蓝儿唯美 医疗
    2014年，克利夫兰诊所（Cleveland Clinic）想要更有效地控制其手术中心做膝关节置换手术的费用。整个系统每年大约进行2600例此类手术，所以，即使降低很少一部分成本，都可以为诊 所和病人节约大量的资金。为了找到适合的解决方案，供应商将视野投向了预测分析技术和工具，但其分析团队还必须花时间向医生解释基于数据的治疗方案意味着 什么。  克利夫兰诊所负责企业信息管理和分析的医疗
  • java 线程(一)：基础篇 DavidIsOK java多线程线程
                                                            &nbs
  • Tomcat服务器框架之Servlet开发分析 aijuans servlet
    最近使用Tomcat做web服务器，使用Servlet技术做开发时，对Tomcat的框架的简易分析： 疑问： 为什么我们在继承HttpServlet类之后，覆盖doGet(HttpServletRequest req, HttpServetResponse rep)方法后，该方法会自动被Tomcat服务器调用，doGet方法的参数有谁传递过来？怎样传递？ 分析之我见： doGet方法的
  • 揭秘玖富的粉丝营销之谜 与小米粉丝社区类似 aoyouzi 揭秘玖富的粉丝营销之谜
    玖富旗下悟空理财凭借着一个微信公众号上线当天成交量即破百万，第七天成交量单日破了1000万;第23天时，累计成交量超1个亿……至今成立不到10个月，粉丝已经超过500万，月交易额突破10亿，而玖富平台目前的总用户数也已经超过了1800万，位居P2P平台第一位。很多互联网金融创业者慕名前来学习效仿，但是却鲜有成功者，玖富的粉丝营销对外至今仍然是个谜。   　　近日，一直坚持微信粉丝营销
  • Java web的会话跟踪技术 百合不是茶 url会话Cookie会话Seession会话Java Web隐藏域会话
    会话跟踪主要是用在用户页面点击不同的页面时,需要用到的技术点   会话:多次请求与响应的过程     1,url地址传递参数,实现页面跟踪技术          格式:传一个参数的 url?名=值     传两个参数的 url?名=值 &名=值   关键代码
  • web.xml之Servlet配置 bijian1013 javaweb.xmlServlet配置
    定义： <servlet> <servlet-name>myservlet</servlet-name> <servlet-class>com.myapp.controller.MyFirstServlet</servlet-class> <init-param> <param-name>
  • 利用svnsync实现SVN同步备份 sunjing SVN同步E000022svnsync镜像
    1. 在备份SVN服务器上建立版本库    svnadmin create test 2. 创建pre-revprop-change文件     cd test/hooks/     cp pre-revprop-change.tmpl pre-revprop-change 3. 修改pre-revprop-
  • 【分布式数据一致性三】MongoDB读写一致性 bit1129 mongodb
    本系列文章结合MongoDB，探讨分布式数据库的数据一致性，这个系列文章包括： 数据一致性概述与CAP 最终一致性(Eventually Consistency) 网络分裂(Network Partition)问题 多数据中心(Multi Data Center) 多个写者(Multi Writer)最终一致性 一致性图表(Consistency Chart) 数据
  • Anychart图表组件-Flash图转IMG普通图的方法 白糖_ Flash
    问题背景：项目使用的是Anychart图表组件，渲染出来的图是Flash的，往往一个页面有时候会有多个flash图，而需求是让我们做一个打印预览和打印功能，让多个Flash图在一个页面上打印出来。   那么我们打印预览的思路是获取页面的body元素，然后在打印预览界面通过$("body").append(html)的形式显示预览效果，结果让人大跌眼镜：Flash是
  • Window 80端口被占用 WHY? bozch 端口占用window
    平时在启动一些可能使用80端口软件的时候，会提示80端口已经被其他软件占用，那一般又会有那些软件占用这些端口呢？    下面坐下总结：         1、web服务器是最经常见的占用80端口的，例如：tomcat , apache  , IIS , Php等等；         2
  • 编程之美-数组的最大值和最小值-分治法（两种形式） bylijinnan 编程之美
    import java.util.Arrays; public class MinMaxInArray { /** * 编程之美 数组的最大值和最小值 分治法 * 两种形式 */ public static void main(String[] args) { int[] t={11,23,34,4,6,7,8,1,2,23}; int[]
  • Perl正则表达式 chenbowen00 正则表达式perl
    首先我们应该知道 Perl 程序中，正则表达式有三种存在形式，他们分别是： 匹配：m/<regexp>;/ （还可以简写为 /<regexp>;/ ，略去 m） 替换：s/<pattern>;/<replacement>;/ 转化：tr/<pattern>;/<replacemnt>;
  • [宇宙与天文]行星议会是否具有本行星大气层以外的权力呢? comsci
          举个例子: 地球,地球上由200多个国家选举出一个代表地球联合体的议会,那么现在地球联合体遇到一个问题,地球这颗星球上面的矿产资源快要采掘完了....那么地球议会全体投票,一致通过一项带有法律性质的议案,既批准地球上的国家用各种技术手段在地球以外开采矿产资源和其它资源........    &
  • Oracle Profile 使用详解 daizj oracleprofile资源限制
    Oracle Profile 使用详解 转 一、目的： Oracle系统中的profile可以用来对用户所能使用的数据库资源进行限制，使用Create Profile命令创建一个Profile，用它来实现对数据库资源的限制使用，如果把该profile分配给用户，则该用户所能使用的数据库资源都在该profile的限制之内。 二、条件： 创建profile必须要有CREATE PROFIL
  • How HipChat Stores And Indexes Billions Of Messages Using ElasticSearch & Redis dengkane elasticsearchLucene
    This article is from an interview with Zuhaib Siddique, a production engineer at HipChat, makers of group chat and IM for teams. HipChat started in an unusual space, one you might not
  • 循环小示例，菲波拉契序列，循环解一元二次方程以及switch示例程序 dcj3sjt126com c算法
    # include <stdio.h> int main(void) { int n; int i; int f1, f2, f3; f1 = 1; f2 = 1; printf("请输入您需要求的想的序列："); scanf("%d", &n); for (i=3; i<n; i
  • macbook的lamp环境 dcj3sjt126com lamp
      sudo vim /etc/apache2/httpd.conf   /Library/WebServer/Documents 是默认的网站根目录   重启Mac上的Apache服务   这个命令很早以前就查过了，但是每次使用的时候还是要在网上查： 停止服务：sudo /usr/sbin/apachectl stop 开启服务：s
  • java ArrayList源码 下 shuizhaosi888 ArrayList源码
    版本 jdk-7u71-windows-x64   JavaSE7 ArrayList源码上：http://flyouwith.iteye.com/blog/2166890     /** * 从这个列表中移除所有c中包含元素 */ public boolean removeAll(Collection<?> c) {
  • Spring Security（08）——intercept-url配置 234390216 Spring Securityintercept-url访问权限访问协议请求方法
    intercept-url配置 目录 1.1     指定拦截的url 1.2     指定访问权限 1.3     指定访问协议 1.4     指定请求方法   1.1   &n
  • Linux环境下的oracle安装 jayung oracle
    linux系统下的oracle安装 本文档是Linux(redhat6.x、centos6.x、redhat7.x) 64位操作系统安装Oracle 11g(Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production)，本文基于各种网络资料精心整理而成，共享给有需要的朋友。如有问题可联系：QQ：52-7
  • hotspot虚拟机 leichenlei javaHotSpotjvm虚拟机文档
    JVM参数  http://docs.oracle.com/javase/6/docs/technotes/guides/vm/index.html   JVM工具 http://docs.oracle.com/javase/6/docs/technotes/tools/index.html   JVM垃圾回收 http://www.oracle.com
  • 读《Node.js项目实践：构建可扩展的Web应用》 ——引编程慢慢变成系统化的“砌砖活” noaighost Webnode.js
    读《Node.js项目实践：构建可扩展的Web应用》 ——引编程慢慢变成系统化的“砌砖活” 眼里的Node.JS 初初接触node是一年前的事，那时候年少不更事。还在纠结什么语言可以编写出牛逼的程序，想必每个码农都会经历这个月经性的问题：微信用什么语言写的？facebook为什么推荐系统这么智能，用什么语言写的？dota2的外挂这么牛逼，用什么语言写的？……用什么语言写这句话，困扰人也是阻碍
  • 快速开发Android应用 rensanning android
    Android应用开发过程中，经常会遇到很多常见的类似问题，解决这些问题需要花时间，其实很多问题已经有了成熟的解决方案，比如很多第三方的开源lib，参考 Android Libraries 和 Android UI/UX Libraries。 编码越少，Bug越少，效率自然会高。 但可能由于 根本没听说过、听说过但没用过、特殊原因不能用、自己已经有了解决方案等等原因，这些成熟的解决
  • 理解Java中的弱引用 tomcat_oracle java工作面试
    　不久之前，我 面试了一些求职Java高级开发工程师的应聘者。我常常会面试他们说，“你能给我介绍一些Java中得弱引用吗？”，如果面试者这样说，“嗯，是不是垃圾回收有关的？”，我就会基本满意了，我并不期待回答是一篇诘究本末的论文描述。 　　然而事与愿违，我很吃惊的发现，在将近20多个有着平均5年开发经验和高学历背景的应聘者中，居然只有两个人知道弱引用的存在，但是在这两个人之中只有一个人真正了
  • 标签输出html标签" target="_blank">关于标签输出html标签 xshdch jsp
    http://back-888888.iteye.com/blog/1181202 关于<c:out value=""/>标签的使用，其中有一个属性是escapeXml默认是true(将html标签当做转移字符，直接显示不在浏览器上面进行解析)，当设置escapeXml属性值为false的时候就是不过滤xml，这样就能在浏览器上解析html标签， &nb
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他