为什么模板只能在头文件中实现？

Question

引用自C++ 标准库：教程和手册：

目前使用模板的唯一可移植方法是使用内联函数在头文件中实现它们。

这是为什么呢？

（澄清：头文件不是唯一的可移植解决方案。但它们是最方便的可移植解决方案。）

Answer 1

警告：没有必要将实现放入头文件中，请参阅本答案末尾的替代解决方案。

无论如何，您的代码失败的原因是，在实例化模板时，编译器使用给定的模板参数创建一个新类。例如：

template<typename T>
struct Foo
{
    T bar;
    void doSomething(T param) {/* do stuff using T */}
};

// somewhere in a .cpp
Foo<int> f; 

当读取这一行时，编译器将创建一个新类（我们称之为 FooInt ），这相当于以下内容：

struct FooInt
{
    int bar;
    void doSomething(int param) {/* do stuff using int */}
};

因此，编译器需要有权访问方法的实现，使用模板参数（在本例中为 int）实例化它们。如果这些实现不在标头中，则它们将不可访问，因此编译器将无法实例化模板。

对此的常见解决方案是将模板声明写入头文件中，然后在实现文件（例如 .tpp）中实现该类，并将该实现文件包含在头文件的末尾。

Foo.h

template <typename T>
struct Foo
{
    void doSomething(T param);
};

#include "Foo.tpp"

Foo.tpp

template <typename T>
void Foo<T>::doSomething(T param)
{
    //implementation
}

这样，实现仍然与声明分离，但可供编译器访问。

替代解决方案

另一个解决方案是保持实现分离，并显式实例化您需要的所有模板实例：

Foo.h

// no implementation
template <typename T> struct Foo { ... };

Foo.cpp

// implementation of Foo's methods

// explicit instantiations
template class Foo<int>;
template class Foo<float>;
// You will only be able to use Foo with int or float

如果我的解释不够清楚，您可以查看 关于此主题的 C++ 超级常见问题解答。

Answer 2

这是因为需要单独编译，并且模板是实例化风格的多态性。

让我们更接近具体的解释。假设我有以下文件：

• foo.h
  • 声明class MyClass的接口
• foo.cpp 的接口
  • 定义class MyClass的实现
• bar.cpp 的实现
  • 使用MyClass

单独编译意味着我应该能够独立于 bar.cpp 编译 foo.cpp。编译器完全独立地在每个编译单元上完成分析、优化和代码生成的所有艰苦工作；我们不需要进行整个程序分析。只有链接器需要立即处理整个程序，并且链接器的工作要容易得多。

当我编译 foo.cpp 时，bar.cpp 甚至不需要存在，但我仍然应该能够链接 foo.o我已经和我刚刚制作的bar.o一起使用了，不需要重新编译foo.cpp。 foo.cpp 甚至可以编译成动态库，在没有 foo.cpp 的情况下分发到其他地方，并与他们在我编写 foo.cpp 多年后编写的代码链接。

“实例化样式多态性”意味着模板 MyClass 实际上并不是一个可以编译为适用于任何 T 值的代码的泛型类。这会增加开销，例如装箱、需要将函数指针传递给分配器和构造函数等。C++ 模板的目的是避免编写几乎相同的 class MyClass_int、class MyClass_float code> 等，但仍然能够最终得到编译后的代码，就像我们单独编写每个版本一样。因此，模板实际上就是一个模板；类模板不是类，它是为我们遇到的每个T创建新类的方法。模板不能编译成代码，只能编译实例化模板的结果。

所以当编译foo.cpp时，编译器看不到bar.cpp来知道需要MyClass。它可以看到模板 MyClass，但它无法为此发出代码（它是模板，而不是类）。而当bar.cpp编译时，编译器可以看到它需要创建一个MyClass，但是却看不到模板MyClass<。 T> （仅其在 foo.h 中的接口），因此无法创建它。

如果 foo.cpp 本身使用 MyClass，则在编译 foo.cpp 时将生成该代码，因此当 bar.o 链接到 foo.o，它们可以连接起来并且可以工作。我们可以利用这一事实，通过编写单个模板来允许在 .cpp 文件中实现一组有限的模板实例化。但是 bar.cpp 无法使用模板作为模板并在它喜欢的任何类型上实例化它；它只能使用 foo.cpp 作者认为提供的模板类的现有版本。

您可能认为在编译模板时，编译器应该“生成所有版本”，而在链接过程中过滤掉从未使用过的版本。除了巨大的开销和这种方法将面临的极端困难之外，因为指针和数组等“类型修饰符”功能甚至允许内置类型产生无限数量的类型，当我现在扩展我的程序时会发生什么通过添加：

• baz.cpp
  • 声明并实现类 BazPrivate，并使用 MyClass

这不可能起作用，除非我们

1. 必须重新编译 foo. 它添加 MyClass 的新实例
2. 每次我们更改程序中的任何其他文件时，cpp，以防 baz.cpp 包含（可能通过标头包含）MyClass 的完整模板，以便编译器可以生成 MyClass在编译baz.cpp期间。

没有人喜欢（1），因为整个程序分析编译系统需要永远来编译，并且因为它使得在没有源代码的情况下无法分发已编译的库。所以我们有（2）。

Answer 3

这里有很多正确的答案，但我想添加这个（为了完整性）：

如果您在实现 cpp 文件的底部，对模板将使用的所有类型进行显式实例化，链接器将能够找到它们照常。

编辑：添加显式模板实例化的示例。在定义模板并且定义所有成员函数后使用。

template class vector<int>;

这将实例化（并因此可供链接器使用）类及其所有成员函数（仅）。类似的语法适用于函数模板，因此如果您有非成员运算符重载，您可能需要对它们执行相同的操作。

上面的例子是相当无用的，因为向量是在标头中完全定义的，除非公共包含文件（预编译标头？）使用外部模板类向量以防止它在所有情况下实例化。使用向量的其他（1000？）文件。

Answer 4

在实际将模板编译为目标代码之前，需要由编译器实例化模板。仅当模板参数已知时才能实现此实例化。现在想象一个场景，模板函数在 ah 中声明，在 a.cpp 中定义并在 b.cpp 中使用。编译 a.cpp 时，不一定知道即将进行的编译 b.cpp 是否需要模板的实例，更不用说具体是哪个实例了。对于更多的头文件和源文件，情况很快就会变得更加复杂。

有人可能会说，编译器可以变得更智能，可以“预见”模板的所有使用，但我确信创建递归或其他复杂的场景并不困难。 AFAIK，编译器不会进行此类前瞻性操作。正如 Anton 指出的，一些编译器支持模板实例化的显式导出声明，但并非所有编译器都支持它（还？）。

Answer 5

实际上，在 C++11 之前，标准定义了 export 关键字，可以在头文件中声明模板并在其他地方实现它们。从某种意义上来说。事实并非如此，因为只有指出：

幽灵优势#1：隐藏源代码。许多用户表示，他们希望通过使用导出，他们将
不再需要为成员/非成员函数模板和类的成员函数提供定义
模板。这不是真的。通过导出，库编写者仍然必须提供完整的模板源代码或其直接
等价的（例如，系统特定的解析树），因为实例化需要完整的信息。 [...]

幻影优势#2：快速构建，减少依赖性。许多用户期望导出能够实现真正的分离
将模板编译为目标代码，他们期望这将允许更快的构建。并不是因为
导出模板的编译确实是分开的，但不是与目标代码分开的。相反，出口几乎总是使
构建速度较慢，因为在预链接时至少仍必须完成相同数量的编译工作。出口
甚至不会减少模板定义之间的依赖关系，因为依赖关系是内在的，
独立于文件组织。

流行的编译器都没有实现这个关键字。该功能的唯一实现是由 Edison Design Group 编写的前端，由 Comeau C++ 编译器使用。所有其他要求您在头文件中编写模板，因为编译器需要模板定义才能正确实例化（正如其他人已经指出的那样）。

因此，ISO C++ 标准委员会决定删除 C++11 模板的导出功能。

Answer 6

尽管标准 C++ 没有这样的要求，但某些编译器要求所有函数和类模板都需要在它们使用的每个翻译单元中可用。实际上，对于这些编译器，模板函数的主体必须在头文件中可用。重复一遍：这意味着这些编译器不允许在非头文件（例如 .cpp 文件）中定义它们。

有一个 export 关键字应该可以缓解这个问题，但它与便于携带。

Answer 7

模板经常在头文件中使用，因为编译器需要实例化不同版本的代码，具体取决于为模板参数给出/推导的参数，并且（作为程序员）让编译器多次重新编译相同的代码并在以后进行重复数据删除会更容易。
请记住，模板并不直接代表代码，而是代表该代码的多个版本的模板。
当您在 .cpp 文件中编译非模板函数时，您正在编译一个具体的函数/类。
模板则不然，模板可以用不同的类型实例化，即用具体类型替换模板参数时必须发出具体代码。

有一个带有 export 关键字的功能，旨在用于单独编译。
export 功能在 C++11 中已被弃用，并且据我所知，只有一个编译器实现了该功能。
您不应该使用导出。
单独编译在 C++ 或 C++11 中是不可能的，但在 C++17 中可能是这样，如果概念允许的话，我们可以有某种单独编译的方式。

为了实现单独编译，必须可以进行单独的模板主体检查。
看来用概念是可以解决的。
最近看一下这篇论文提出于
标准委员会会议。
我认为这不是唯一的要求，因为您仍然需要在用户代码中实例化模板代码的代码。

模板的单独编译问题我想这也是迁移到模块时出现的问题，目前正在处理中。

编辑：截至 2020 年 8 月，模块已经成为 C++ 的现实： https://en.cppreference .com/w/cpp/语言/模块

Answer 8

尽管上面有很多很好的解释，但我缺少一种将模板分为标题和正文的实用方法。

我主要关心的是当我更改其定义时避免重新编译所有模板用户。

将所有模板实例化在模板主体中对我来说不是一个可行的解决方案，因为模板作者可能不知道其用法，并且模板用户可能无权修改它。

我采用了以下方法，该方法也适用于较旧的编译器（gcc 4.3.4、aCC A.03.13）。

对于每个模板的使用，其自己的头文件（从 UML 模型生成）中都有一个 typedef。它的主体包含实例化（最终位于最后链接的库中）。

模板的每个用户都包含该头文件并使用 typedef。

示意性示例：

MyTemplate.h:

#ifndef MyTemplate_h
#define MyTemplate_h 1

template <class T>
class MyTemplate
{
public:
  MyTemplate(const T& rt);
  void dump();
  T t;
};

#endif

MyTemplate.cpp:

#include "MyTemplate.h"
#include <iostream>

template <class T>
MyTemplate<T>::MyTemplate(const T& rt)
: t(rt)
{
}

template <class T>
void MyTemplate<T>::dump()
{
  cerr << t << endl;
}

MyInstantiatedTemplate.h:

#ifndef MyInstantiatedTemplate_h
#define MyInstantiatedTemplate_h 1
#include "MyTemplate.h"

typedef MyTemplate< int > MyInstantiatedTemplate;

#endif

MyInstantiatedTemplate.cpp:

#include "MyTemplate.cpp"

template class MyTemplate< int >;

main.cpp：

#include "MyInstantiatedTemplate.h"

int main()
{
  MyInstantiatedTemplate m(100);
  m.dump();
  return 0;
}

这样，只有模板实例需要重新编译，而不是所有模板用户（和依赖项）。

Answer 9

这意味着定义模板类的方法实现的最可移植的方法是在模板类定义中定义它们。

template < typename ... >
class MyClass
{

    int myMethod()
    {
       // Not just declaration. Add method implementation here
    }
};

Answer 10

当您在编译步骤中使用模板时，编译器将为每个模板实例化生成代码。
在编译和链接过程中，.cpp 文件被转换为纯对象或机器代码，其中包含引用或未定义的符号，因为 main.cpp 中包含的 .h 文件尚未实现。这些已准备好与另一个定义模板实现的目标文件链接，因此您拥有完整的 a.out 可执行文件。

然而，由于模板需要在编译步骤中进行处理，以便为您定义的每个模板实例化生成代码，因此简单地编译与其头文件分开的模板是行不通的，因为它们总是齐头并进，正是出于这个原因每个模板实例化实际上都是一个全新的类。在常规类中，您可以将 .h 和 .cpp 分开，因为 .h 是该类的蓝图，而 .cpp 是原始实现，因此可以定期编译和链接任何实现文件，但是使用模板 .h 是如何进行的蓝图类的外观不应该是对象的外观，这意味着模板 .cpp 文件不是类的原始常规实现，它只是类的蓝图，因此无法编译 .h 模板文件的任何实现，因为你需要需要具体编译的东西，模板在这个意义上是抽象的。

因此，模板永远不会单独编译，并且仅在其他源文件中具有具体实例的地方进行编译。但是，具体实例化需要知道模板文件的实现，因为简单地使用 .h 文件中的具体类型修改 typename T 并不能完成这项工作，因为 .cpp 在那里链接，我稍后找不到它，因为记住模板是抽象的并且无法编译，所以我现在被迫给出实现，这样我就知道要编译和链接什么，现在我有了实现它被链接到封闭的源文件中。基本上，当我实例化一个模板时，我需要创建一个全新的类，如果我不知道该类在使用我提供的类型时应该是什么样子，我就不能这样做，除非我通知编译器模板实现，因此现在编译器可以用我的类型替换 T 并创建一个可供编译和链接的具体类。

总而言之，模板是类应该如何显示的蓝图，类是对象应该如何显示的蓝图。
我无法将模板与具体实例化分开编译，因为编译器只编译具体类型，换句话说，模板至少在 C++ 中是纯粹的语言抽象。可以这么说，我们必须对模板进行去抽象，为此我们需要给它们一个具体的类型来处理，以便我们的模板抽象可以转换为常规的类文件，进而可以正常编译。将模板.h 文件和模板.cpp 文件分开是没有意义的。这是荒谬的，因为 .cpp 和 .h 的分离只是 .cpp 可以单独编译和单独链接的地方，而模板则不能单独编译，因为模板是一个抽象，因此我们总是被迫将抽象始终与具体实例化放在一起，其中具体实例化始终必须了解所使用的类型。

这意味着 typename T 在编译步骤而不是链接步骤中被替换，因此如果我尝试编译模板而不将 T 替换为具体值类型，这对编译器因此无法创建目标代码，因为它不知道 T 是什么。

从技术上讲，创建某种功能来保存 template.cpp 文件并在其他来源中找到类型时可以切换它们，我认为该标准确实有一个关键字 export ，它将允许您将模板放入单独的 cpp 文件中，但实际上并没有多少编译器实现此功能。

附带说明一下，在对模板类进行专门化时，您可以将标头与实现分开，因为根据定义的专门化意味着我专门针对可以单独编译和链接的具体类型。

Answer 11

如果担心的是通过将 .h 编译为所有使用它的 .cpp 模块的一部分而产生的额外编译时间和二进制大小膨胀，在许多情况下，您可以做的是使模板类从非模板化基类派生接口的非类型相关部分，并且该基类可以在 .cpp 文件中拥有其实现。

Answer 12

只是在这里添加一些值得注意的内容。当模板类的方法不是函数模板时，可以在实现文件中很好地定义它们。

---

myQueue.hpp：

template <class T> 
class QueueA {
    int size;
    ...
public:
    template <class T> T dequeue() {
       // implementation here
    }

    bool isEmpty();

    ...
}    

---

myQueue.cpp：

// implementation of regular methods goes like this:
template <class T> bool QueueA<T>::isEmpty() {
    return this->size == 0;
}


main()
{
    QueueA<char> Q;

    ...
}

Answer 13

单独实现的一种方式如下。

inner_foo.h

template <typename T>
struct Foo
{
    void doSomething(T param);
};

foo.tpp

#include "inner_foo.h"

template <typename T>
void Foo<T>::doSomething(T param)
{
    //implementation
}

foo.h

#include <foo.tpp>

main.cpp

#include <foo.h>

inner_foo.h 具有前向声明。 foo.tpp 具有实现并包含 inner_foo.h；并且 foo.h 将只有一行，以包含 foo.tpp。

在编译时，foo.h 的内容被复制到 foo.tpp，然后整个文件被复制到 foo.h，之后编译。这样就没有任何限制，命名也一致，换来的是多一个文件。

我这样做是因为代码的静态分析器在看不到 *.tpp 中类的前向声明时会中断。在任何 IDE 中编写代码或使用 YouCompleteMe 或其他工具时，这很烦人。

Answer 14

这是完全正确的，因为编译器必须知道要分配的类型。因此，如果要将模板类、函数、枚举等公开或作为库的一部分（静态或动态），则也必须在头文件中实现，因为头文件不像 c/cpp 文件那样进行编译。是。如果编译器不知道类型就无法编译它。在 .Net 中可以，因为所有对象都派生自 Object 类。这不是.Net。

Answer 15

我建议查看这个 gcc 页面，其中讨论了模板实例化的“cfront”和“borland”模型之间的权衡。

https://gcc.gnu.org/onlinedocs/gcc -4.6.4/gcc/Template-Instantiation.html

“borland”模型对应于作者的建议，提供完整的模板定义，并多次编译。

它包含有关使用手动和自动模板实例化的明确建议。例如，“-repo”选项可用于收集需要实例化的模板。或者另一种选择是使用“-fno-implicit-templates”禁用自动模板实例化，以强制手动模板实例化。

根据我的经验，我依赖于为每个编译单元实例化的 C++ 标准库和 Boost 模板（使用模板库）。对于我的大型模板类，我会针对我需要的类型进行一次手动模板实例化。

这是我的方法，因为我提供的是一个工作程序，而不是用于其他程序的模板库。这本书的作者 Josuttis 在模板库方面做了很多工作。

如果我真的担心速度，我想我会探索使用预编译头
https://gcc.gnu.org/onlinedocs/gcc/Precompiled-Headers.html

正在获得许多编译器的支持。但是，我认为预编译头对于模板头文件来说会很困难。

Answer 16

（从封闭重复复制到这里）

我更喜欢将我的所有函数都放在 .cpp 文件中，无论它们是模板函数还是常规函数。有一种方法可以通过一些基本的#ifndef 魔法来做到这一点。您可以执行以下操作：

main.cpp

#include "myclass.hpp"

int main()
{
  // ...
}

myclass.hpp

#ifndef MYCLASS
#define MYCLASS

template<class T>
class MyClass
{
  T val;
public:
  MyClass(T val_);
}

#define MYCLASS_FUNCTIONS
#include "myclass.cpp"

#endif

myclass.cpp

#ifndef MYCLASS_FUNCTIONS
#include "myclass.hpp"

// regular functions:
// ...

#else
 
// template functions:
template<class T>
MyClass<T>::MyClass(T val_)
    :val(val_)
{}

// ...
#endif

以下是预编译器如何看待它。我们有两个 .cpp 文件。

1. 当我们编译 main.cpp 时，我们：
2. 包含 myclass.hpp
3. 检查 MYCLASS 是否未定义，并且它已
4. 定义，它
5. 为编译器提供生成类的定义（来自模板类）
6. include myclass.cpp
7. Define MYCLASS_FUNCTIONS
8. 检查MYCLASS_FUNCTIONS是否已定义，它为
9. 编译器提供了生成函数的定义（来自模板函数）
10. 当我们编译 myclass.cpp
11. 检查 MYCLASS_FUNCTIONS 是否已定义，它不
12. 包含 myclass.hpp
13. 检查 MYCLASS 是否未定义，并且已
14. 定义它
15. 为编译器提供类的定义
16. include myclass.cpp
17. 再次包含 myclass.hpp
18. 这次定义了 MYCLASS，因此在内部不执行任何操作，返回myclass.cpp
19. 检查是否定义了MYCLASS_FUNCTIONS，它为
20. 编译器提供了生成函数的定义（来自模板函数）
21. exit include 两次
22. 将所有常规函数传递给编译器

Answer 17

受到 Moshe 的回答的启发： https://stackoverflow.com/a/38448106/6459849

我这边的一个小贡献有一个扩展的例子。假设有一个整体的OperationSuccess，它包含一个ResponseSuccess，其中有一个通用类型。

ResponseSuccess.h

template <class T>
class ResponseSuccess {
public:
    ResponseSuccess(const ResponseStatus responseStatus, const T& data) :
        m_responseStatus(responseStatus),
        m_data(data) {}

    ~ResponseSuccess() = default;

    // Basis requirement, have Copy/Move constructor/delete assignment operator

    ResponseStatus getResponseStatus() const {
        return m_responseStatus;
    }

    T getData() const {
        return m_data;
    };

private:
    ResponseStatus m_responseStatus;

    T m_data;
};

OperationSuccess.h

template <class T>
class OperationResponse {
public:
    explicit OperationResponse(ResponseSuccess<T> responseSuccess) :
        m_responseSuccess(std::move(responseSuccess)) {}

    ~OperationResponse() = default;
    // Basis requirement, have Copy/Move constructor/delete assignment operator

    ResponseSuccess<T> getResponseSuccess() const {
        return m_responseSuccess;
    }

private:
    ResponseSuccess<T> m_responseSuccess;
    // have a failure, in case required
};

用法：

MyObject myObj(<ctor_args>);
    ResponseSuccess<MyObject> responseSuccess(ResponseStatus::SUCCESS, myObj);
    OperationResponse<MyObject> successOperationResponse(responseSuccess);
..
// Fetches the response -> successOperationResponse.getResponseSuccess();

Answer 18

C++20 允许 auto 作为函数参数类型，

void func(auto param) {
  // do stuff
}

这使得 缩写函数模板。编译器还需要访问函数的实现，以使用推导的参数类型实例化它。因此，实现应该在头文件中。

使用 auto 参数无法实现将单独实现保留在源文件中的替代解决方案。如果需要，可以将 auto 参数替换为类型化模板参数。

// func.hh

template <typename T>
void func(T param);

// func.cc

template <typename T>
void func(T param) {            // implementation
  // do stuff
}

template void func(int param);  // explicit instantiation for int parameter

// main.cc

#include <func.hh>

int main() {
  func(1);    // ok
  func(1LL);  // link error
}

// cc func.cc main.cc

Answer 19

在头文件中编写声明和定义的另一个好主意是为了提高可读性。假设Utility.h中有这样一个模板函数：

template <class T>
T min(T const& one, T const& theOther);

而在Utility.cpp中：

#include "Utility.h"
template <class T>
T min(T const& one, T const& other)
{
    return one < other ? one : other;
}

这需要这里的每个T类都实现小于运算符（<）。当您比较两个未实现“<”的类实例时，它将引发编译器错误。

因此，如果您将模板声明和定义分开，您将无法仅读取头文件来查看此模板的来龙去脉，以便在您自己的类上使用此 API，尽管编译器会在此处告诉您关于需要覆盖哪个运算符的情况。

Answer 20

我必须编写一个模板类，这个示例对我有用

这是动态数组类的示例。

#ifndef dynarray_h
#define dynarray_h

#include <iostream>

template <class T>
class DynArray{
    int capacity_;
    int size_;
    T* data;
public:
    explicit DynArray(int size = 0, int capacity=2);
    DynArray(const DynArray& d1);
    ~DynArray();
    T& operator[]( const int index);
    void operator=(const DynArray<T>& d1);
    int size();
    
    int capacity();
    void clear();
    
    void push_back(int n);
    
    void pop_back();
    T& at(const int n);
    T& back();
    T& front();
};

#include "dynarray.template" // this is how you get the header file

#endif

现在，在 .template 文件中，您可以像平常一样定义函数。

template <class T>
DynArray<T>::DynArray(int size, int capacity){
    if (capacity >= size){
        this->size_ = size;
        this->capacity_ = capacity;
        data = new T[capacity];
    }
    //    for (int i = 0; i < size; ++i) {
    //        data[i] = 0;
    //    }
}

template <class T>
DynArray<T>::DynArray(const DynArray& d1){
    //clear();
    //delete [] data;
    std::cout << "copy" << std::endl;
    this->size_ = d1.size_;
    this->capacity_ = d1.capacity_;
    data = new T[capacity()];
    for(int i = 0; i < size(); ++i){
        data[i] = d1.data[i];
    }
}

template <class T>
DynArray<T>::~DynArray(){
    delete [] data;
}

template <class T>
T& DynArray<T>::operator[]( const int index){
    return at(index);
}

template <class T>
void DynArray<T>::operator=(const DynArray<T>& d1){
    if (this->size() > 0) {
        clear();
    }
    std::cout << "assign" << std::endl;
    this->size_ = d1.size_;
    this->capacity_ = d1.capacity_;
    data = new T[capacity()];
    for(int i = 0; i < size(); ++i){
        data[i] = d1.data[i];
    }
    
    //delete [] d1.data;
}

template <class T>
int DynArray<T>::size(){
    return size_;
}

template <class T>
int DynArray<T>::capacity(){
    return capacity_;
}

template <class T>
void DynArray<T>::clear(){
    for( int i = 0; i < size(); ++i){
        data[i] = 0;
    }
    size_ = 0;
    capacity_ = 2;
}

template <class T>
void DynArray<T>::push_back(int n){
    if (size() >= capacity()) {
        std::cout << "grow" << std::endl;
        //redo the array
        T* copy = new T[capacity_ + 40];
        for (int i = 0; i < size(); ++i) {
            copy[i] = data[i];
        }
        
        delete [] data;
        data = new T[ capacity_ * 2];
        for (int i = 0; i < capacity() * 2; ++i) {
            data[i] = copy[i];
        }
        delete [] copy;
        capacity_ *= 2;
    }
    data[size()] = n;
    ++size_;
}

template <class T>
void DynArray<T>::pop_back(){
    data[size()-1] = 0;
    --size_;
}

template <class T>
T& DynArray<T>::at(const int n){
    if (n >= size()) {
        throw std::runtime_error("invalid index");
    }
    return data[n];
}

template <class T>
T& DynArray<T>::back(){
    if (size() == 0) {
        throw std::runtime_error("vector is empty");
    }
    return data[size()-1];
}

template <class T>
T& DynArray<T>::front(){
    if (size() == 0) {
        throw std::runtime_error("vector is empty");
    }
    return data[0];
    }