Lưu trữ định nghĩa hàm mẫu C ++ trong tệp .CPP

Tôi có một số mã mẫu mà tôi muốn lưu trữ trong tệp CPP thay vì nội tuyến trong tiêu đề. Tôi biết điều này có thể được thực hiện miễn là bạn biết loại mẫu nào sẽ được sử dụng. Ví dụ:

tập tin .h

class foo
{
public:
    template <typename T>
    void do(const T& t);
};

tập tin .cpp

template <typename T>
void foo::do(const T& t)
{
    // Do something with t
}

template void foo::do<int>(const int&);
template void foo::do<std::string>(const std::string&);

Lưu ý hai dòng cuối cùng - hàm foo :: do template chỉ được sử dụng với chuỗi ints và std ::, vì vậy những định nghĩa đó có nghĩa là ứng dụng sẽ liên kết.

Câu hỏi của tôi là - đây có phải là một hack khó chịu hay nó sẽ hoạt động với các trình biên dịch / liên kết khác? Hiện tại tôi chỉ sử dụng mã này với VS2008 nhưng sẽ muốn chuyển sang các môi trường khác.

Vấn đề bạn mô tả có thể được giải quyết bằng cách xác định mẫu trong tiêu đề hoặc thông qua cách tiếp cận bạn mô tả ở trên.

Tôi khuyên bạn nên đọc các điểm sau từ C ++ FAQ Lite :

• Tại sao tôi không thể tách định nghĩa của lớp mẫu của mình khỏi khai báo và đặt nó trong tệp .cpp?
• Làm cách nào để tránh lỗi liên kết với các chức năng mẫu của tôi?
• Làm thế nào để xuất từ ​​khóa C ++ giúp với các lỗi liên kết mẫu?

Họ đi sâu vào rất nhiều chi tiết về các vấn đề mẫu này (và khác).

Đối với những người khác trên trang này tự hỏi cú pháp chính xác là gì (như tôi) đối với chuyên môn mẫu rõ ràng (hoặc ít nhất là trong VS2008), đây là ...

Trong tệp .h của bạn ...

template<typename T>
class foo
{
public:
    void bar(const T &t);
};

Và trong tệp .cpp của bạn

template <class T>
void foo<T>::bar(const T &t)
{ }

// Explicit template instantiation
template class foo<int>;

Mã này được hình thành tốt. Bạn chỉ cần chú ý rằng định nghĩa của mẫu có thể nhìn thấy tại điểm khởi tạo. Để trích dẫn tiêu chuẩn, § 14.7.2.4:

Định nghĩa của mẫu hàm không được xuất, mẫu hàm thành viên không được xuất hoặc hàm thành viên không được xuất hoặc thành viên dữ liệu tĩnh của mẫu lớp sẽ được trình bày trong mọi đơn vị dịch mà nó được khởi tạo rõ ràng.

Điều này sẽ hoạt động tốt ở mọi nơi mẫu được hỗ trợ. Khởi tạo mẫu rõ ràng là một phần của tiêu chuẩn C ++.

Ví dụ của bạn là chính xác nhưng không phải là rất di động. Ngoài ra còn có một cú pháp sạch hơn một chút có thể được sử dụng (như được chỉ ra bởi @ namepace-sid).

Giả sử lớp templated là một phần của một số thư viện sẽ được chia sẻ. Các phiên bản khác của lớp templated nên được biên dịch? Là người duy trì thư viện có nghĩa vụ phải dự đoán tất cả các cách sử dụng templated có thể có của lớp?

Một cách tiếp cận thay thế là một biến thể nhỏ trên những gì bạn có: thêm tệp thứ ba là tệp thực hiện / khởi tạo mẫu.

tập tin foo.h

// Standard header file guards omitted

template <typename T>
class foo
{
public:
    void bar(const T& t);
};

tập tin foo.cpp

// Always include your headers
#include "foo.h"

template <typename T>
void foo::bar(const T& t)
{
    // Do something with t
}

tập tin foo-impl.cpp

// Yes, we include the .cpp file
#include "foo.cpp"
template class foo<int>;

Một lưu ý là bạn cần yêu cầu trình biên dịch biên dịch foo-impl.cppthay vì foo.cppbiên dịch cái sau không làm gì cả.

Tất nhiên, bạn có thể có nhiều triển khai trong tệp thứ ba hoặc có nhiều tệp triển khai cho từng loại bạn muốn sử dụng.

Điều này cho phép linh hoạt hơn nhiều khi chia sẻ lớp templated cho các mục đích sử dụng khác.

Thiết lập này cũng giảm thời gian biên dịch cho các lớp được sử dụng lại vì bạn không biên dịch lại cùng một tệp tiêu đề trong mỗi đơn vị dịch.

Đây chắc chắn không phải là một hack khó chịu, nhưng lưu ý rằng bạn sẽ phải thực hiện nó (chuyên môn mẫu rõ ràng) cho mọi lớp / loại bạn muốn sử dụng với mẫu đã cho. Trong trường hợp NHIỀU loại yêu cầu khởi tạo mẫu, có thể có RẤT NHIỀU dòng trong tệp .cpp của bạn. Để khắc phục vấn đề này, bạn có thể có TemplateClassInst.cpp trong mọi dự án bạn sử dụng để bạn có quyền kiểm soát tốt hơn các loại sẽ được khởi tạo. Rõ ràng giải pháp này sẽ không hoàn hảo (hay còn gọi là viên đạn bạc) vì cuối cùng bạn có thể phá vỡ ODR :).

Có, trong tiêu chuẩn mới nhất, một từ khóa (export ) sẽ giúp giảm bớt vấn đề này, nhưng nó không được triển khai trong bất kỳ trình biên dịch nào mà tôi biết, ngoài Comeau.

Xem FAQ-lite về điều này.

Đó là một cách tiêu chuẩn để xác định các chức năng mẫu. Tôi nghĩ có ba phương pháp tôi đọc để xác định mẫu. Hoặc có lẽ 4. Mỗi người có ưu và nhược điểm.

1. Xác định trong định nghĩa lớp. Tôi hoàn toàn không thích điều này bởi vì tôi nghĩ định nghĩa lớp học hoàn toàn mang tính tham khảo và nên dễ đọc. Tuy nhiên, việc xác định các mẫu trong lớp ít hơn nhiều so với bên ngoài. Và không phải tất cả các khai báo mẫu đều có cùng mức độ phức tạp. Phương pháp này cũng làm cho mẫu trở thành một mẫu thực sự.

2. Xác định mẫu trong cùng một tiêu đề, nhưng bên ngoài lớp. Đây là cách ưa thích của tôi hầu hết thời gian. Nó giữ cho định nghĩa lớp của bạn gọn gàng, mẫu vẫn là một mẫu thực sự. Tuy nhiên, nó đòi hỏi phải đặt tên mẫu đầy đủ có thể khó khăn. Ngoài ra, mã của bạn có sẵn cho tất cả. Nhưng nếu bạn cần mã của mình để được nội tuyến thì đây là cách duy nhất. Bạn cũng có thể thực hiện điều này bằng cách tạo tệp .INL ở cuối định nghĩa lớp của bạn.

3. Bao gồm tiêu đề.h và hiện thực.CPP vào main.CPP của bạn. Tôi nghĩ đó là cách nó được thực hiện. Bạn sẽ không phải chuẩn bị bất kỳ cảnh báo trước nào, nó sẽ hoạt động như một khuôn mẫu thực sự. Vấn đề tôi có với nó là nó không tự nhiên. Chúng tôi thường không bao gồm và mong đợi bao gồm các tệp nguồn. Tôi đoán vì bạn đã bao gồm tệp nguồn, các hàm mẫu có thể được nội tuyến.

4. Phương pháp cuối cùng này, là cách được đăng, đang xác định các mẫu trong tệp nguồn, giống như số 3; nhưng thay vì bao gồm tệp nguồn, chúng tôi khởi tạo trước các mẫu mà chúng tôi sẽ cần. Tôi không có vấn đề với phương pháp này và đôi khi nó có ích. Chúng tôi có một mã lớn, nó không thể hưởng lợi từ việc được nội tuyến, vì vậy chỉ cần đặt nó vào tệp CPP. Và nếu chúng ta biết các cảnh báo phổ biến và chúng ta có thể xác định trước chúng. Điều này giúp chúng ta tiết kiệm từ việc viết về cơ bản cùng một điều 5, 10 lần. Phương pháp này có lợi ích giữ cho mã của chúng tôi độc quyền. Nhưng tôi không khuyên bạn nên đặt các chức năng nhỏ, được sử dụng thường xuyên trong các tệp CPP. Vì điều này sẽ làm giảm hiệu suất của thư viện của bạn.

Lưu ý, tôi không nhận thức được hậu quả của một tập tin obj cồng kềnh.

Vâng, đó là cách tiêu chuẩn để thực hiện khởi tạo chuyên môn rõ ràng. Như bạn đã nêu, bạn không thể khởi tạo mẫu này với các loại khác.

Chỉnh sửa: sửa dựa trên nhận xét.

Hãy lấy một ví dụ, giả sử vì một số lý do bạn muốn có một lớp mẫu:

//test_template.h:
#pragma once
#include <cstdio>

template <class T>
class DemoT
{
public:
    void test()
    {
        printf("ok\n");
    }
};

template <>
void DemoT<int>::test()
{
    printf("int test (int)\n");
}


template <>
void DemoT<bool>::test()
{
    printf("int test (bool)\n");
}

Nếu bạn biên dịch mã này với Visual Studio - nó sẽ hoạt động tốt. gcc sẽ tạo ra lỗi liên kết (nếu cùng một tệp tiêu đề được sử dụng từ nhiều tệp .cpp):

error : multiple definition of `DemoT<int>::test()'; your.o: .../test_template.h:16: first defined here

Có thể di chuyển thực hiện sang tệp .cpp, nhưng sau đó bạn cần khai báo lớp như thế này -

//test_template.h:
#pragma once
#include <cstdio>

template <class T>
class DemoT
{
public:
    void test()
    {
        printf("ok\n");
    }
};

template <>
void DemoT<int>::test();

template <>
void DemoT<bool>::test();

// Instantiate parametrized template classes, implementation resides on .cpp side.
template class DemoT<bool>;
template class DemoT<int>;

Và sau đó .cpp sẽ trông như thế này:

//test_template.cpp:
#include "test_template.h"

template <>
void DemoT<int>::test()
{
    printf("int test (int)\n");
}


template <>
void DemoT<bool>::test()
{
    printf("int test (bool)\n");
}

Không có hai dòng cuối cùng trong tệp tiêu đề - gcc sẽ hoạt động tốt, nhưng Visual studio sẽ tạo ra lỗi:

 error LNK2019: unresolved external symbol "public: void __cdecl DemoT<int>::test(void)" (?test@?$DemoT@H@@QEAAXXZ) referenced in function

cú pháp lớp mẫu là tùy chọn trong trường hợp nếu bạn muốn hiển thị chức năng thông qua xuất khẩu, nhưng điều này chỉ áp dụng cho nền tảng windows - vì vậy test_template.h có thể trông như thế này:

//test_template.h:
#pragma once
#include <cstdio>

template <class T>
class DemoT
{
public:
    void test()
    {
        printf("ok\n");
    }
};

#ifdef _WIN32
    #define DLL_EXPORT __declspec(dllexport) 
#else
    #define DLL_EXPORT
#endif

template <>
void DLL_EXPORT DemoT<int>::test();

template <>
void DLL_EXPORT DemoT<bool>::test();

với tập tin .cpp từ ví dụ trước.

Tuy nhiên, điều này gây đau đầu hơn cho trình liên kết, do đó, nên sử dụng ví dụ trước nếu bạn không xuất hàm.

Thời gian để cập nhật! Tạo một tệp nội tuyến (.inl, hoặc có thể là bất kỳ tệp nào khác) và chỉ cần sao chép tất cả các định nghĩa của bạn trong đó. Hãy chắc chắn để thêm mẫu ở trên mỗi chức năng ( template <typename T, ...>). Bây giờ thay vì bao gồm tệp tiêu đề trong tệp nội tuyến, bạn làm ngược lại. Bao gồm tệp nội tuyến sau khi khai báo lớp của bạn (#include "file.inl" ).

Tôi thực sự không biết tại sao không ai đề cập đến điều này. Tôi thấy không có nhược điểm ngay lập tức.

Không có gì sai với ví dụ bạn đã đưa ra. Nhưng tôi phải nói rằng tôi tin rằng việc lưu trữ các định nghĩa hàm trong tệp cpp không hiệu quả. Tôi chỉ hiểu sự cần thiết phải phân tách khai báo và định nghĩa của hàm.

Khi được sử dụng cùng với khởi tạo lớp rõ ràng, Thư viện kiểm tra khái niệm Boost (BCCL) có thể giúp bạn tạo mã chức năng mẫu trong các tệp cpp.

Không có cách nào ở trên làm việc cho tôi, vì vậy đây là cách bạn giải quyết nó, lớp tôi chỉ có 1 phương thức templated ..

.h

class Model
{
    template <class T>
    void build(T* b, uint32_t number);
};

.cpp

#include "Model.h"
template <class T>
void Model::build(T* b, uint32_t number)
{
    //implementation
}

void TemporaryFunction()
{
    Model m;
    m.build<B1>(new B1(),1);
    m.build<B2>(new B2(), 1);
    m.build<B3>(new B3(), 1);
}

điều này tránh các lỗi liên kết và không cần phải gọi tạm thời