C++ 如何为不同的模板专门化制作一个计数器？ #包括 #包括 使用名称空间std； 模板 班级学生成绩 { 字符串名； 内特诺埃克斯姆斯； T*等级(ptr)； 静态整数计数器； 公众： 学生成绩（字符串n，整数编号） { name=n； NoExams=否； 等级_ptr=新T[编号]； 计数器++； } 作废打印（） { cout

您可以使用基类，其目的是统计实例数：

#include<string>
#include<iostream>
using namespace std;

template<class T>
class Student_Grades
{
    string name;
    int NoExams;
    T *grades_ptr;
    static int counter;

public:
    Student_Grades(string n, int no)
    {
        name=n;
        NoExams=no;
        grades_ptr=new T[no];
        counter++;
    }

    void Print()
    {
        cout<<"Name: "<<name<<endl;
        cout<<"NoExams: "<<NoExams<<endl;
        for(int i=0; i<NoExams; i++)
        {
            cout<<"Grade "<<i+1<<": "<<grades_ptr[i]<<endl;
        }
        cout<<endl<<endl;
    }

    void set_grade(int index, T grade)
    {
        grades_ptr[index]=grade;    
    }

    T get_grade(int index)
    {
        return grades_ptr[index];
    }

    int get_counter()
    {
        return counter;
    }

    ~Student_Grades()
    {
        delete[] grades_ptr;
        counter--;
    }
};

#包括
结构B{
B（）{cnt++；}
虚拟~B（）{cnt--；}
静态int-cnt；
};
int B：：cnt=0；
模板
结构D:B{
D（）：B{}{}
};
int main（）{
D d1；
D d2；
断言（B：：cnt==2）；
}

这样，它就不依赖于专业化的类型

更具可配置性的解决方案是：

#include<cassert>

struct B {
    B() { cnt++; }
    virtual ~B() { cnt--; }
    static int cnt;
};

int B::cnt = 0;

template<typename T>
struct D: B {
    D(): B{} { }
};

int main() {
    D<int> d1;
    D<float> d2;
    assert(B::cnt == 2);
}

#包括
结构C{
C（）{cnt++；}
虚拟~C（）{cnt--；}
静态int-cnt；
};
int C：：cnt=0；
模板
结构D：计数器{}；
int main（）{
D d1；
D d2；
断言（C:：cnt==2）；
}

如果您不想依赖继承，请选择此选项：

#include<cassert>

struct C {
    C() { cnt++; }
    virtual ~C() { cnt--; }
    static int cnt;
};

int C::cnt = 0;

template<typename T, class Counter = C>
struct D: Counter { };

int main() {
    D<int> d1;
    D<float> d2;
    assert(C::cnt == 2);
}

#包括
结构C{
C（）{cnt++；}
~C（）{cnt--；}
静态int-cnt；
};
int C：：cnt=0；
模板
结构D{const Counter c；}；
int main（）{
D d1；
D d2；
断言（C:：cnt==2）；
}

---

等等…

您不需要使用静态成员变量，而是使用全局变量。将其放置在模板之外。例如，在公共基类中。是的，我刚刚考虑过。非常基本，抱歉：）谢谢

#include<cassert>

struct C {
    C() { cnt++; }
    ~C() { cnt--; }
    static int cnt;
};

int C::cnt = 0;

template<typename T, class Counter = C>
struct D { const Counter c; };

int main() {
    D<int> d1;
    D<float> d2;
    assert(C::cnt == 2);
}