链接的时候出现了问题。这个是因为静态变量没有在外部声明或定义。
出现该问题的程序如下：
#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() {