error LNK2001: 无法解析的外部符号 “private: static int Student::total_count“ (?total_count@Student@@0HA)

 链接的时候出现了问题。这个是因为静态变量没有在外部声明或定义。

出现该问题的程序如下：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <set>
#include <map>
#include <algorithm>

using namespace std;

class Student {
public:
	Student() {
		total_count++;
	}
	Student(char* name, char& sex, char* clazz, int& uid, float& grade) {
		total_count++;
	}
	~Student() {
		total_count--;
	}
	void set_name(char *name) {
		if (strlen(name) >= 20) {
			memcpy(this->name, name, 19);
			this->name[19] = '\0';
			return;
		}
		memcpy(this->name, name, strlen(name) + 1);
	}
	char* get_name() {
		return this->name;
	}
	void set_sex(char &sex) {
		this->sex = sex;
	}
	char get_sex() {
		return this->sex;
	}
	void set_clazz(char* clazz) {
		if (strlen(clazz) >= 20) {
			memcpy(this->clazz, clazz, 19);
			this->clazz[19] = '\0';
			return;
		}
		memcpy(this->clazz, clazz, strlen(clazz) + 1);
	}
	char* get_clazz() {
		return this->clazz;
	}
	void set_uid(int uid) {
		this->uid = uid;
	}
	int get_uid() {
		return this->uid;
	}
	void set_grade(float grade) {
		if (grade < 10) this->grade = 10.0f;
		else if (grade > 100) this->grade = 100.0f;
		else this->grade = grade;
	}
	float get_grade() {
		return this->grade;
	}
	friend ostream& operator<<(ostream& output, const Student& stu) {
		output << stu.uid << ' ' << stu.name <<
			' ' << stu.sex << ' ' << stu.clazz << ' ' << stu.grade;
		return output;
	}
	friend istream& operator>>(istream& input, Student& stu) {
		input >> stu.uid >> stu.name >> stu.sex >> stu.clazz >> stu.grade;
		return input;
	}
private:
	char name[20];
	char sex;
	char clazz[20];
	int uid;
	float grade;
	static int total_count;
};

template <class T>
class Node {
public:
	Node<T> *next;
	Node<T> *prev;
	T data;
};

template <class T>
class List {
public:
	List();//默认构造函数
	List(const List& ln);//拷贝构造函数
	~List();//析构函数
	void add(T e);//向链表添加数据
	void ascSort();//升序排序
	void remove(T index);//移除某个结点
	T find(int index);//查找结点
	bool isEmpty();//判断是否为空
	int size();//链表长度
	void show();//显示链表
	void resShow();//链表反向显示
	void removeAll();//删除全部结点
private:
	Node<T> *head;
	Node<T> *tail;
	int length;
};

//默认构造函数
template <typename T>
List<T>::List() {
	head = new Node<T>;
	tail = new Node<T>;
	head->next = tail;
	head->prev = nullptr;
	tail->next = nullptr;
	tail->prev = head;
	length = 0;
}
//拷贝构造函数
template <typename T>
List<T>::List(const List &ln) {
	head = new Node<T>;
	head->prev = nullptr;
	tail = new Node<T>;
	head->next = tail;
	tail->prev = head;
	length = 0;
	Node<T>* temp = ln.head;
	while (temp->next != ln.tail) {
		temp = temp->next;
		tail->data = temp->data;
		Node<T> *p = new Node<T>;
		p->prev = tail;
		tail->next = p;
		tail = p;
		length++;
	}
	tail->next = nullptr;
}
//判断是否为空
template <typename T>
bool List<T>::isEmpty() {
	return length == 0;
}
//向链表添加数据
template <typename T>
void List<T>::add(T e) {
	Node<T>* temp = this->tail;
	tail->data = e;
	tail->next = new Node<T>;
	Node<T> *p = tail;
	tail = tail->next;
	tail->prev = p;
	tail->next = nullptr;
	length++;
}
//查找结点
template <typename T>
T List<T>::find(int index) {
	if (this->isEmpty()) {
		std::cout << "List is empty";
		return NULL;
	}
	if (index >= length) {
		std::cout << "Out of bounds";
		return NULL;
	}
	int x = 0;
	T data;
	Node<T> *p;
	p = head->next;
	while (p->next != nullptr && x++ != index) {
		p = p->next;
	}
	return p->data;
}
//删除结点
template <typename T>
void List<T>::remove(T index) {
	if (this->isEmpty()) {
		std::cout << "List is empty";
		return;
	}
	Node<T> *p = head;
	while (p->next != nullptr) {
		p = p->next;
		if (p->data == index) {
			Node<T> *temp = p->prev;
			temp->next = p->next;
			p->next->prev = temp;
			delete p;
			length--;
			return;
		}
	}
}
//删除所有结点
template <typename T>
void List<T>::removeAll() {
	if (this->isEmpty()) {
		return;
	}
	Node<T> *p = head->next;
	while (p != tail) {
		Node<T>* temp = p;
		p = p->next;
		delete temp;
	}
	head->next = tail;
	tail->prev = head;
	length = 0;
}
//升序排序
template <typename T>
void List<T>::ascSort() {
	if (length <= 1) return;
	Node<T> *p = head->next;
	for (int i = 0; i < length - 1; i++) {
		Node<T> *q = p->next;
		for (int j = i + 1; j < length; j++) {
			if (p->data > q->data) {
				T temp = q->data;
				q->data = p->data;
				p->data = temp;
			}
			q = q->next;
		}
		p = p->next;
	}
}
//链表长度
template <typename T>
int List<T>::size() {
	return length;
}
//输出链表
template <typename T>
void List<T>::show() {
	if (this->isEmpty()) {
		std::cout << "List is empty" << std::endl;
		return;
	}
	Node<T> *p = head->next;
	while (p != tail) {
		std::cout << p->data << " ";
		p = p->next;
	}
	std::cout << std::endl;
}
//反向输出链表
template <typename T>
void List<T>::resShow() {
	if (this->isEmpty) return;
	Node<T> *p = tail->prev;
	while (p != head) {
		std::cout << p->data << " ";
		p = p->prev;
	}
	std::cout << std::endl;
}
//析构函数
template <typename T>
List<T>::~List() {
	if (this->isEmpty()) {
		delete head;
		delete tail;
		head = nullptr;
		tail = nullptr;
		return;
	}
	while (head->next != nullptr) {
		Node<T> *temp = head;
		head = head->next;
		delete temp;
	}
	delete head;
	head = nullptr;
}

int main() {
	List<Student> list;
	int n;
	cout << "n=";
	cin >> n;
	for (int i = 0; i < n; i++) {
		Student stu;
		cin >> stu;
		list.add(stu);
	}
	cout << "====== Show All =======" << endl;
	list.show();
	return 0;
}

在外部加上变量声明就可以了

}

int Student::total_count;

int main() {

当然可以进行初始化定义 

}

int Student::total_count = 0;

int main() {