0

我正在努力理解使用extern说明符的模板显式实例化。这是我的例子”

// 电源.h

template <typename T>
class Power
{
public:
    T operator()(T const& x) {return x * x;}
};

// 电源.cpp

#include "power.h"

template
class Power<int>;

//mathlib.h

class Square
{
public:
    Square(int);
    inline int side()const { return side_;}
    int surface()const;
    int perim()const;

private:
    int side_{};
};

// 数学库.cpp

#include "mathlib.h"
#include "power.h"

extern template class Power<int>;

Square::Square(int x) :
    side_(x)
{}

int Square::surface() const
{
    return Power<int>{}(side_);
}

int Square::perim() const
{
    return side_ * 4;
}

//physiqlib.h

class Planet
{
public:
    Planet(int);
    int velocity()const;

private:
    int veloc_{};
};

//physiqlib.cpp

#include "physiqlib.h"
#include "power.h"

extern template class Power<int>;


Planet::Planet(int v) :
    veloc_(v)
{}

int Planet::velocity()const
{
    return Power<int>{}(veloc_);
}

//main.cpp

#include <iostream>
#include "mathlib.h"
#include "physiqlib.h"
#include "power.h"

int main()
{

    Square sq{7};
    std::cout << "side: " << sq.side() << '\n';
    std::cout << "surface: " << sq.surface() << '\n';
    std::cout << "perim: " << sq.perim() << '\n';

    std::cout << '\n';
    std::cout << "Planet name: Earth\n";
    Planet plEarth(150000);
    std::cout << "velocity: " << plEarth.velocity() << '\n';

    std::cout << "\ndone!\n";
}

  • 当我编译程序时，它可以正常工作并给我正确的结果但是我想知道这是否Explicit instantiation有效？

  • 我很抱歉写了我的整个程序，但我只是想展示我是如何使用它的。

  • 为了简洁起见，我还举了一个任意的例子，并从标题中删除了包含保护。

  • 请指导我是否走在正确的道路上，特别是我在论坛上进行了搜索，我仍然有点困惑。

** 如果我从生成中间文件的终端编译程序：g++ -S -save-temps main.cpp physiqlib.cpp power.cpp mathlib.cpp 为什么我会在每个*.ii模板类中得到一个定义Power？像这样的东西：

// 数学库.ii

# 1 "mathlib.cpp"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "mathlib.cpp"
# 1 "mathlib.h" 1
    

class Square
{
public:
    Square(int);
    inline int side()const { return side_;}
    int surface()const;
    int perim()const;

private:
    int side_{};
};
# 2 "mathlib.cpp" 2
# 1 "power.h" 1



template <typename T>
class Power
{
public:
    T operator()(T const& x) {return x * x;}
};
# 3 "mathlib.cpp" 2

extern template class Power<int>;

Square::Square(int x) :
    side_(x)
{}

int Square::surface() const
{
    return Power<int>{}(side_);
}

int Square::perim() const
{
    return side_ * 4;
}

  • 这是否意味着类模板Power仅被定义但尚未实例化并且实例化class Power<int>在其他地方？

  • 如果我是正确的，新标准是否可以使用这种技术来避免模板代码膨胀？

太感谢了！

4

1 回答 1

1

我想知道这是否是显式实例化的工作方式？

是的。

为什么我在每个 *.ii 中得到一个模板类 Power 的定义？

*.ii 文件是预处理阶段的结果。与模板实例化无关。

这是否意味着类模板 Power 仅被定义但尚未实例化，而实例化类 Power 在别处？

是的，调用没有进行隐式实例化return Power<int>{}(side_);

如果我是正确的，新标准是否可以使用这种技术来避免模板代码膨胀？

它可能会减少一些，它可以节省编译时间，因为只实例化一次。即使在单个翻译单元中，多次实例化仍可能发生代码膨胀。

有关class_template#Explicit_instantiation的更多详细信息

于 2020-11-11T00:20:38.063 回答