Question

有可能做出这样的事情：

class Tag1;
class Tag2;

template <typename Tag>
void foo(){}    

void bar()
{
    //here I nee to know how many times I have referenced foo<Tag1> and foo<Tag2>

    //code chunk
    //...

    foo<Tag1>();

    //another code chunk

    foo<Tag2>();

    //much more of code and calls of foo
    ...
}

我需要在巨大的计算上取得一些进展。

P.S。我需要在编译时知道它。 Foo不需要是函数，它可以是对象而不是宏。

Answer 1

如果你想分别计算每个标签，那么你只需创建一个静态变量并递增它：

template <typename Tag>
void foo() {
    static int x = 0;
    ++x;
    // ...
}

Answer 2

我们可以使用typeid和map来跟踪创建的对象类型。

#include <iostream>
#include <string>
#include <typeinfo>
#include <map>
#include <algorithm>

using namespace std;

class Tag1{};
class Tag2{};

map<string, int> typeCountMap;

void getTypeCount(const string& tagname)
{
    map<string, int>::iterator itr = typeCountMap.find(tagname);

    if(itr != typeCountMap.end())
        typeCountMap[tagname] += 1;
    else
        typeCountMap[tagname] = 1;
}

template <typename Tag>
void foo(){
    getTypeCount(typeid(Tag).name());


}    

void bar()
{
    //here I nee to know how many times I have referenced foo<Tag1> and foo<Tag2>

    //code chunk
    //...

    foo<Tag1>();

    //another code chunk

    foo<Tag2>();

    //much more of code and calls of foo
    //...
}

void print(const pair<std::string, int>& entry)
{

    cout<<"type ["<<entry.first<<"] value ["<<entry.second<<"]"<<endl;
}

int main()
{
    bar();
    bar();
    bar();
    foo<Tag2>();

    for_each(typeCountMap.begin(), typeCountMap.end(), print);   
   return 0;
}


/*
output
type [4Tag1] value [3]                                                                                                                                          
type [4Tag2] value [4]
*/

计算编译时代码中引用的对象的时间

2 个答案: