Tại sao không suy ra tham số mẫu từ hàm tạo?

câu hỏi của tôi hôm nay khá đơn giản: tại sao trình biên dịch không thể suy ra các tham số mẫu từ các hàm tạo lớp, nhiều như nó có thể làm từ các tham số hàm? Ví dụ: tại sao mã sau không thể hợp lệ:

template<typename obj>
class Variable {
      obj data;
      public: Variable(obj d)
              {
                   data = d;
              }
};

int main()
{
    int num = 2;
    Variable var(num); //would be equivalent to Variable<int> var(num),
    return 0;          //but actually a compile error
}

Như tôi đã nói, tôi hiểu rằng điều này không hợp lệ, vì vậy câu hỏi của tôi là tại sao lại không? Việc cho phép điều này có tạo ra bất kỳ lỗ hổng cú pháp chính nào không? Có trường hợp nào mà người ta không muốn có chức năng này (trong đó việc suy luận một kiểu sẽ gây ra vấn đề) không? Tôi chỉ đang cố gắng hiểu logic đằng sau việc cho phép suy luận mẫu cho các hàm, nhưng không phải cho các lớp được xây dựng phù hợp.

Tôi nghĩ rằng nó không hợp lệ vì hàm tạo không phải lúc nào cũng là điểm vào duy nhất của lớp (tôi đang nói về hàm tạo bản sao và toán tử =). Vì vậy, giả sử bạn đang sử dụng lớp của mình như thế này:

MyClass m(string s);
MyClass *pm;
*pm = m;

Tôi không chắc liệu trình phân tích cú pháp có rõ ràng như vậy không khi biết loại khuôn mẫu nào là pm MyClass;

Không chắc liệu những gì tôi nói có hợp lý không nhưng hãy bình luận thêm, đó là một câu hỏi thú vị.

C ++ 17

Người ta chấp nhận rằng C ++ 17 sẽ có kiểu trừ từ các đối số của hàm tạo.

Ví dụ:

std::pair p(2, 4.5);
std::tuple t(4, 3, 2.5);

Giấy được chấp nhận .

Bạn không thể làm những gì bạn yêu cầu vì những lý do mà người khác đã giải quyết, nhưng bạn có thể làm điều này:

template<typename T>
class Variable {
    public: Variable(T d) {}
};
template<typename T>
Variable<T> make_variable(T instance) {
  return Variable<T>(instance);
}

cho tất cả mục đích và mục đích cũng giống như điều bạn yêu cầu. Nếu bạn thích đóng gói, bạn có thể làm cho make_variable một hàm thành viên tĩnh. Đó là cái mà người ta gọi là hàm tạo có tên. Vì vậy, nó không chỉ làm những gì bạn muốn mà còn gần như được gọi là những gì bạn muốn: trình biên dịch đang truyền tham số mẫu từ hàm tạo (được đặt tên).

NB: bất kỳ trình biên dịch hợp lý nào sẽ tối ưu hóa đối tượng tạm thời khi bạn viết một cái gì đó như

auto v = make_variable(instance);

Trong thời đại khai sáng năm 2016, với hai tiêu chuẩn mới của chúng tôi kể từ khi câu hỏi này được đặt ra và một tiêu chuẩn mới sắp xuất hiện, điều quan trọng cần biết là các trình biên dịch hỗ trợ tiêu chuẩn C ++ 17 sẽ biên dịch mã của bạn như hiện tại. .

Khấu trừ đối số mẫu cho các mẫu lớp trong C ++ 17

Đây (với sự chỉnh sửa của Olzhas Zhumabek về câu trả lời được chấp nhận) là bài báo trình bày chi tiết những thay đổi liên quan đối với tiêu chuẩn.

Giải quyết mối quan tâm từ các câu trả lời khác

Câu trả lời được xếp hạng hàng đầu hiện tại

Câu trả lời này chỉ ra rằng "phương thức tạo bản sao và operator=" sẽ không biết các chuyên ngành mẫu chính xác.

Điều này là vô nghĩa, bởi vì hàm tạo bản sao tiêu chuẩn và operator= chỉ tồn tại cho một loại mẫu đã biết :

template <typename T>
class MyClass {
    MyClass(const MyClass&) =default;
    ... etc...
};

// usage example modified from the answer
MyClass m(string("blah blah blah"));
MyClass *pm;   // WHAT IS THIS?
*pm = m;

Ở đây, như tôi đã lưu ý trong các ý kiến, có không có lý do để MyClass *pmtrở thành một tuyên bố pháp lý có hoặc không có các hình thức mới của suy luận: MyClass không phải là một loại (đó là một mẫu), do đó nó không có ý nghĩa để khai báo một con trỏ của loại MyClass. Đây là một cách có thể để sửa ví dụ:

MyClass m(string("blah blah blah"));
decltype(m) *pm;               // uses type inference!
*pm = m;

Dưới đây, pmlà đã về đúng loại, và do đó suy luận là tầm thường. Hơn nữa, không thể vô tình trộn các kiểu khi gọi hàm tạo bản sao:

MyClass m(string("blah blah blah"));
auto pm = &(MyClass(m));

Đây, pmsẽ là một con trỏ đến một bản sao của m. Ở đây, MyClassđang được sao chép xây dựng từ m— loại nào MyClass<string>(và không thuộc loại không tồn tại MyClass). Do đó, tại điểm mà pm's loại được suy ra, có là đủ thông tin để biết rằng mẫu-loại m, và do đó mẫu-loại pm, là string.

Hơn nữa, phần sau sẽ luôn phát sinh lỗi biên dịch :

MyClass s(string("blah blah blah"));
MyClass i(3);
i = s;

Điều này là do khai báo của hàm tạo bản sao không được tạo mẫu:

MyClass(const MyClass&);

Ở đây, kiểu mẫu của đối số copy-constructor khớp với kiểu mẫu của lớp nói chung; tức là, khi nào MyClass<string>được khởi tạo, MyClass<string>::MyClass(const MyClass<string>&);được khởi tạo cùng với nó, và khi nào MyClass<int>được khởi tạo, MyClass<int>::MyClass(const MyClass<int>&);được khởi tạo. Trừ khi nó được chỉ định rõ ràng hoặc một phương thức khởi tạo được tạo mẫu được khai báo, không có lý do gì để trình biên dịch khởi tạo MyClass<int>::MyClass(const MyClass<string>&);, điều này rõ ràng là không phù hợp.

Câu trả lời của Cătălin Pitiș

Pitiș đưa ra một ví dụ về suy luận Variable<int>và Variable<double>sau đó nói:

Tôi có cùng một tên loại (Biến) trong mã cho hai loại khác nhau (Biến và Biến). Theo quan điểm chủ quan của tôi, nó ảnh hưởng khá nhiều đến khả năng đọc của mã.

Như đã lưu ý trong ví dụ trước, Variablebản thân nó không phải là một tên kiểu, mặc dù tính năng mới làm cho nó giống như một cú pháp.

Pitiș sau đó hỏi điều gì sẽ xảy ra nếu không có hàm tạo nào được đưa ra để cho phép suy luận thích hợp. Câu trả lời là không cho phép suy luận, bởi vì suy luận được kích hoạt bởi lời gọi hàm tạo . Không có lời gọi hàm tạo, không có suy luận .

Điều này tương tự như hỏi phiên bản nào foođược suy ra ở đây:

template <typename T> foo();
foo();

Câu trả lời là mã này là bất hợp pháp, vì lý do đã nêu.

Câu trả lời của MSalter

Theo như tôi có thể nói thì đây là câu trả lời duy nhất để đưa ra mối quan tâm chính đáng về tính năng được đề xuất.

Ví dụ là:

Variable var(num);  // If equivalent to Variable<int> var(num),
Variable var2(var); // Variable<int> or Variable<Variable<int>> ?

Câu hỏi quan trọng là, trình biên dịch chọn hàm tạo suy ra kiểu ở đây hay hàm tạo sao chép ?

Thử mã ra, chúng ta có thể thấy rằng hàm tạo bản sao đã được chọn. Để mở rộng ví dụ :

Variable var(num);          // infering ctor
Variable var2(var);         // copy ctor
Variable var3(move(var));   // move ctor
// Variable var4(Variable(num));     // compiler error

Tôi không chắc đề xuất và phiên bản mới của tiêu chuẩn quy định điều này như thế nào; nó dường như được xác định bởi "hướng dẫn khấu trừ", là một chút tiêu chuẩn mới mà tôi chưa hiểu.

Tôi cũng không chắc tại sao var4khoản khấu trừ là bất hợp pháp; lỗi trình biên dịch từ g ++ dường như chỉ ra rằng câu lệnh đang được phân tích cú pháp như một khai báo hàm.

Vẫn còn thiếu: Nó làm cho mã sau khá mơ hồ:

int main()
{
    int num = 2;
    Variable var(num);  // If equivalent to Variable<int> var(num),
    Variable var2(var); //Variable<int> or Variable<Variable<int>> ?
}

Giả sử rằng trình biên dịch hỗ trợ những gì bạn yêu cầu. Sau đó, mã này hợp lệ:

Variable v1( 10); // Variable<int>

// Some code here

Variable v2( 20.4); // Variable<double>

Bây giờ, tôi có cùng một tên loại (Biến) trong mã cho hai loại khác nhau (Biến và Biến). Theo quan điểm chủ quan của tôi, nó ảnh hưởng khá nhiều đến khả năng đọc của mã. Có cùng một tên kiểu cho hai kiểu khác nhau trong cùng một không gian tên sẽ gây hiểu lầm cho tôi.

Cập nhật sau: Một điều khác cần xem xét: chuyên môn hóa một phần (hoặc toàn bộ) mẫu.

Điều gì sẽ xảy ra nếu tôi chuyên biệt hóa Biến và không cung cấp hàm tạo như bạn mong đợi?

Vì vậy, tôi sẽ có:

template<>
class Variable<int>
{
// Provide default constructor only.
};

Sau đó, tôi có mã:

Variable v( 10);

Trình biên dịch phải làm gì? Sử dụng định nghĩa lớp Biến chung chung để suy ra rằng đó là Biến, sau đó khám phá rằng Biến không cung cấp một hàm tạo tham số?

C ++ 03 và C ++ 11 tiêu chuẩn không cho phép khấu trừ đối số mẫu từ các tham số được truyền cho hằng số.

Nhưng có một đề xuất cho "Suy ra tham số mẫu cho các hàm tạo" để bạn có thể sớm nhận được những gì bạn yêu cầu. Chỉnh sửa: thực sự, tính năng này đã được xác nhận cho C ++ 17.

Xem: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3602.html và http://www.open-std.org/jtc1/sc22/wg21/docs/ paper / 2015 / p0091r0.html

Rất nhiều lớp không phụ thuộc vào các tham số của hàm tạo. Chỉ có một số lớp chỉ có một hàm tạo và tham số hóa dựa trên (các) kiểu của hàm tạo này.

Nếu bạn thực sự cần suy luận mẫu, hãy sử dụng hàm trợ giúp:

template<typename obj>
class Variable 
{
      obj data;
public: 
      Variable(obj d)
      : data(d)
      { }
};

template<typename obj>
inline Variable<obj> makeVariable(const obj& d)
{
    return Variable<obj>(d);
}

Khấu trừ kiểu bị giới hạn trong các hàm mẫu trong C ++ hiện tại, nhưng từ lâu người ta đã nhận ra rằng việc khấu trừ kiểu trong các ngữ cảnh khác sẽ rất hữu ích. Do đó C ++ 0x's auto.

Mặc dù chính xác những gì bạn đề xuất sẽ không thể thực hiện được trong C ++ 0x, nhưng những điều sau đây cho thấy bạn có thể đến khá gần:

template <class X>
Variable<typename std::remove_reference<X>::type> MakeVariable(X&& x)
{
    // remove reference required for the case that x is an lvalue
    return Variable<typename std::remove_reference<X>::type>(std::forward(x));
}

void test()
{
    auto v = MakeVariable(2); // v is of type Variable<int>
}

Bạn nói đúng, trình biên dịch có thể dễ dàng đoán được, nhưng nó không nằm trong tiêu chuẩn hoặc C ++ 0x theo như tôi biết, vì vậy bạn sẽ phải đợi ít nhất 10 năm nữa (tỷ lệ quay vòng cố định tiêu chuẩn ISO) trước khi các nhà cung cấp trình biên dịch thêm tính năng này

Hãy xem xét vấn đề với tham chiếu đến một lớp mà mọi người nên quen thuộc với - std :: vector.

Đầu tiên, một cách sử dụng vector rất phổ biến là sử dụng hàm tạo không nhận tham số:

vector <int> v;

Trong trường hợp này, rõ ràng là không thể suy luận được.

Cách sử dụng phổ biến thứ hai là tạo một vectơ có kích thước trước:

vector <string> v(100);

Ở đây, nếu suy luận được sử dụng:

vector v(100);

chúng ta nhận được một vectơ gồm int, không phải chuỗi, và có lẽ nó không có kích thước!

Cuối cùng, hãy xem xét các hàm tạo nhận nhiều tham số - với "suy luận":

vector v( 100, foobar() );      // foobar is some class

Tham số nào nên được sử dụng để suy luận? Chúng tôi sẽ cần một số cách để nói với trình biên dịch rằng nó phải là trình biên dịch thứ hai.

Với tất cả những vấn đề này cho một lớp đơn giản như vector, thật dễ dàng để hiểu tại sao suy luận không được sử dụng.

Đặt ctor làm mẫu, Biến có thể chỉ có một biểu mẫu nhưng có nhiều ctor khác nhau:

class Variable {
      obj data; // let the compiler guess
      public:
      template<typename obj>
      Variable(obj d)
       {
           data = d;
       }
};

int main()
{
    int num = 2;
    Variable var(num);  // Variable::data int?

    float num2 = 2.0f;
    Variable var2(num2);  // Variable::data float?
    return 0;         
}

Xem? Chúng ta không thể có nhiều thành viên dữ liệu Variable ::.

Xem Phần khấu trừ đối số của mẫu C ++ để biết thêm thông tin về điều này.