ทำไมไม่อนุมานพารามิเตอร์เทมเพลตจากตัวสร้าง

คำถามของฉันวันนี้ค่อนข้างง่าย: ทำไมคอมไพเลอร์ไม่สามารถสรุปพารามิเตอร์เทมเพลตจากตัวสร้างคลาสได้มากเท่าที่จะทำได้จากพารามิเตอร์ฟังก์ชัน ตัวอย่างเช่นเหตุใดรหัสต่อไปนี้จึงไม่ถูกต้อง:

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
}

อย่างที่ฉันพูดฉันเข้าใจว่ามันไม่ถูกต้องดังนั้นคำถามของฉันคือทำไมไม่เป็นเช่นนั้น? จะช่วยให้สิ่งนี้สร้างช่องทางไวยากรณ์ที่สำคัญหรือไม่? มีอินสแตนซ์ที่ใครไม่ต้องการฟังก์ชันนี้ (โดยที่การอนุมานประเภทจะทำให้เกิดปัญหา)? ฉันแค่พยายามเข้าใจตรรกะเบื้องหลังการอนุญาตให้มีการอนุมานเทมเพลตสำหรับฟังก์ชัน แต่ไม่ใช่สำหรับคลาสที่สร้างขึ้นอย่างเหมาะสม

ฉันคิดว่ามันไม่ถูกต้องเพราะตัวสร้างไม่ใช่จุดเดียวของการเข้าคลาสเสมอไป (ฉันกำลังพูดถึงตัวสร้างการคัดลอกและตัวดำเนินการ =) สมมติว่าคุณกำลังใช้ชั้นเรียนของคุณดังนี้:

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

ฉันไม่แน่ใจว่ามันจะชัดเจนขนาดนี้สำหรับตัวแยกวิเคราะห์ที่จะรู้ว่า MyClass เป็นเทมเพลตประเภทใด

ไม่แน่ใจว่าสิ่งที่ฉันพูดนั้นสมเหตุสมผลหรือไม่ แต่อย่าลังเลที่จะเพิ่มความคิดเห็นนั่นเป็นคำถามที่น่าสนใจ

C ++ 17

เป็นที่ยอมรับว่า C ++ 17 จะมีการหักประเภทจากอาร์กิวเมนต์ตัวสร้าง

ตัวอย่าง:

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

กระดาษได้รับการยอมรับ

คุณไม่สามารถทำตามที่ขอด้วยเหตุผลที่คนอื่นพูดถึง แต่คุณสามารถทำได้:

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

ซึ่งสำหรับเจตนาและวัตถุประสงค์ทั้งหมดเป็นสิ่งเดียวกับที่คุณขอ ถ้าคุณชอบการห่อหุ้มคุณสามารถทำให้ make_variable เป็นฟังก์ชันสมาชิกแบบคงที่ นั่นคือสิ่งที่ผู้คนเรียกว่าคอนสตรัคเตอร์ที่มีชื่อว่า ดังนั้นไม่เพียง แต่ทำในสิ่งที่คุณต้องการเท่านั้น แต่เกือบจะเรียกได้ว่าเป็นสิ่งที่คุณต้องการ: คอมไพเลอร์กำลังอนุมานพารามิเตอร์เทมเพลตจากตัวสร้าง (ชื่อ)

หมายเหตุ: คอมไพเลอร์ที่สมเหตุสมผลใด ๆ จะเพิ่มประสิทธิภาพวัตถุชั่วคราวเมื่อคุณเขียนสิ่งที่ต้องการ

auto v = make_variable(instance);

ในยุคแห่งการรู้แจ้งของปี 2559 ด้วยมาตรฐานใหม่สองมาตรฐานภายใต้เข็มขัดของเราเนื่องจากคำถามนี้ถูกถามและคำถามใหม่ที่อยู่ใกล้ ๆ สิ่งสำคัญที่ต้องรู้คือคอมไพเลอร์ที่รองรับมาตรฐาน C ++ 17 จะรวบรวมโค้ดของคุณตามที่เป็นอยู่ .

การหักอาร์กิวเมนต์เทมเพลตสำหรับเทมเพลตคลาสใน C ++ 17

ที่นี่ (ได้รับความอนุเคราะห์จากการแก้ไขโดย Olzhas Zhumabek สำหรับคำตอบที่ยอมรับ) เป็นเอกสารที่มีรายละเอียดการเปลี่ยนแปลงที่เกี่ยวข้องกับมาตรฐาน

จัดการข้อกังวลจากคำตอบอื่น ๆ

คำตอบยอดนิยมในปัจจุบัน

คำตอบนี้ชี้ให้เห็นว่า "ตัวสร้างการคัดลอกและoperator=" ไม่ทราบถึงความเชี่ยวชาญพิเศษของเทมเพลตที่ถูกต้อง

นี่เป็นเรื่องไร้สาระเนื่องจากตัวสร้างสำเนามาตรฐานและoperator= มีอยู่สำหรับประเภทเทมเพลตที่รู้จักเท่านั้น:

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;

ที่นี่ที่ผมตั้งข้อสังเกตในความคิดเห็นที่มีไม่มีเหตุผลสำหรับการMyClass *pmที่จะเป็นคำชี้แจงทางกฎหมายที่มีหรือไม่มีรูปแบบใหม่ของการอนุมาน: MyClass ไม่ได้เป็นประเภท (เป็นแม่แบบ) ดังนั้นจึงไม่ได้ทำให้ความรู้สึกที่จะประกาศตัวชี้ของ ประเภทMyClass. นี่เป็นวิธีหนึ่งที่เป็นไปได้ในการแก้ไขตัวอย่าง:

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

ที่นี่pmเป็นประเภทที่ถูกต้องอยู่แล้วดังนั้นการอนุมานจึงเป็นเรื่องเล็กน้อย ยิ่งไปกว่านั้นมันเป็นไปไม่ได้ที่จะผสมประเภทโดยบังเอิญเมื่อเรียกตัวสร้างสำเนา:

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

ที่นี่pmจะเป็นตัวชี้ไปยังสำเนาของmไฟล์. ที่นี่MyClassกำลังสร้างสำเนาจากm- ซึ่งเป็นประเภทMyClass<string>( ไม่ใช่ประเภทที่ไม่มีอยู่MyClass) ดังนั้นที่จุดที่pmพิมพ์ 's อนุมานได้มีเป็นข้อมูลที่เพียงพอที่จะรู้ว่าแม่แบบชนิดของmและดังนั้นจึงแม่แบบประเภทของการเป็นpmstring

ยิ่งไปกว่านั้นสิ่งต่อไปนี้จะทำให้เกิดข้อผิดพลาดในการคอมไพล์เสมอ :

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

เนื่องจากการประกาศของตัวสร้างการคัดลอกไม่มีเทมเพลต:

MyClass(const MyClass&);

ที่นี่ประเภทเทมเพลตของอาร์กิวเมนต์ copy-constructor ตรงกับ template-type ของคลาสโดยรวม กล่าวคือเมื่อMyClass<string>มีการสร้างอินสแตนซ์MyClass<string>::MyClass(const MyClass<string>&);จะถูกสร้างอินสแตนซ์กับมันและเมื่อMyClass<int>ถูกสร้างอินสแตนซ์MyClass<int>::MyClass(const MyClass<int>&);จะถูกสร้างอินสแตนซ์ เว้นแต่จะมีการระบุไว้อย่างชัดเจนหรือมีการประกาศตัวสร้างเทมเพลตไม่มีเหตุผลใดที่คอมไพลเลอร์จะสร้างอินสแตนซ์MyClass<int>::MyClass(const MyClass<string>&);ซึ่งเห็นได้ชัดว่าไม่เหมาะสม

คำตอบโดยCătălin Pitiș

Pitişให้ตัวอย่าง deducing Variable<int>และVariable<double>แล้วสหรัฐฯ:

ฉันมีชื่อประเภทเดียวกัน (ตัวแปร) ในรหัสสำหรับสองประเภทที่แตกต่างกัน (ตัวแปรและตัวแปร) จากมุมมองส่วนตัวของฉันมันมีผลต่อการอ่านโค้ดค่อนข้างมาก

ที่ระบุไว้ในตัวอย่างก่อนหน้านี้Variableตัวเองเป็นไม่ได้ชื่อประเภทแม้ว่าคุณลักษณะใหม่ที่ทำให้มันมีลักษณะเหมือนหนึ่ง syntactically

จากนั้น Pitiș ก็ถามว่าจะเกิดอะไรขึ้นหากไม่มีการกำหนดตัวสร้างที่จะอนุญาตการอนุมานที่เหมาะสม คำตอบก็คือไม่มีการอนุมานได้รับอนุญาตเพราะการอนุมานจะถูกเรียกโดยโทรคอนสตรัค โดยไม่ต้องมีคอนสตรัคโทรมีไม่มีการอนุมาน

คล้ายกับการถามว่าfooมีการอนุมานเวอร์ชันใดที่นี่:

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

คำตอบคือรหัสนี้ผิดกฎหมายด้วยเหตุผลที่ระบุไว้

คำตอบของ MSalter

เท่าที่ฉันสามารถบอกได้คำตอบเดียวที่จะทำให้เกิดข้อกังวลที่ถูกต้องเกี่ยวกับคุณลักษณะที่เสนอ

ตัวอย่างคือ:

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

คำถามสำคัญคือคอมไพลเลอร์เลือกตัวสร้างที่อนุมานประเภทที่นี่หรือตัวสร้างการคัดลอก ?

ลองใช้รหัสเราจะเห็นว่ามีการเลือกตัวสร้างการคัดลอก หากต้องการขยายตัวอย่าง :

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

ฉันไม่แน่ใจว่าข้อเสนอและมาตรฐานเวอร์ชันใหม่ระบุสิ่งนี้อย่างไร ดูเหมือนว่าจะถูกกำหนดโดย "คู่มือการหัก" ซึ่งเป็นมาตรฐานใหม่ที่ฉันยังไม่เข้าใจ

ฉันก็ไม่แน่ใจเหมือนกันว่าทำไมการvar4หักเงินจึงผิดกฎหมาย ข้อผิดพลาดของคอมไพเลอร์จาก g ++ ดูเหมือนจะบ่งชี้ว่าคำสั่งกำลังถูกแยกวิเคราะห์เป็นการประกาศฟังก์ชัน

ยังคงหายไป: ทำให้รหัสต่อไปนี้ค่อนข้างคลุมเครือ:

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

สมมติว่าคอมไพเลอร์สนับสนุนสิ่งที่คุณถาม รหัสนี้ถูกต้อง:

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

// Some code here

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

ตอนนี้ฉันมีชื่อประเภทเดียวกัน (ตัวแปร) ในรหัสสำหรับสองประเภทที่แตกต่างกัน (ตัวแปรและตัวแปร) จากมุมมองส่วนตัวของฉันมันมีผลต่อการอ่านโค้ดค่อนข้างมาก การมีชื่อประเภทเดียวกันสำหรับสองประเภทที่แตกต่างกันในเนมสเปซเดียวกันทำให้ฉันเข้าใจผิด

การอัปเดตในภายหลัง: สิ่งที่ควรพิจารณาอีกประการหนึ่ง: ความเชี่ยวชาญพิเศษของเทมเพลตบางส่วน (หรือทั้งหมด)

จะเป็นอย่างไรหากฉันเชี่ยวชาญ Variable และไม่มีตัวสร้างอย่างที่คุณคาดหวัง

ดังนั้นฉันจะมี:

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

จากนั้นฉันมีรหัส:

Variable v( 10);

คอมไพเลอร์ควรทำอย่างไร? ใช้นิยามคลาสตัวแปรทั่วไปเพื่ออนุมานว่าเป็นตัวแปรแล้วค้นพบว่าตัวแปรไม่ได้ให้ตัวสร้างพารามิเตอร์เดียว?

มาตรฐาน C ++ 03 และ C ++ 11 ไม่อนุญาตให้มีการหักอาร์กิวเมนต์เทมเพลตจากพารามิเตอร์ที่ส่งไปยังตัวสร้าง

แต่มีข้อเสนอสำหรับ "การหักค่าพารามิเตอร์เทมเพลตสำหรับตัวสร้าง" ดังนั้นคุณอาจได้รับสิ่งที่ต้องการในไม่ช้า แก้ไข: แน่นอนคุณสมบัตินี้ได้รับการยืนยันสำหรับ C ++ 17

ดู: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3602.htmlและhttp://www.open-std.org/jtc1/sc22/wg21/docs/ เอกสาร / 2015 / p0091r0.html

คลาสจำนวนมากไม่ได้ขึ้นอยู่กับพารามิเตอร์ตัวสร้าง มีเพียงไม่กี่คลาสที่มีตัวสร้างเพียงตัวเดียวและกำหนดพารามิเตอร์ตามชนิดของตัวสร้างนี้

หากคุณต้องการการอนุมานเทมเพลตจริงๆให้ใช้ฟังก์ชันตัวช่วย:

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);
}

การหักประเภทจะ จำกัด เฉพาะฟังก์ชันเทมเพลตใน C ++ ปัจจุบัน แต่เป็นที่ทราบกันมานานแล้วว่าการหักประเภทในบริบทอื่น ๆ จะมีประโยชน์มาก ดังนั้น autoC

ในขณะที่ว่าสิ่งที่คุณแนะนำจะไม่เป็นไปใน C ++ 0x แสดงให้เห็นต่อไปนี้คุณจะได้รับสวยใกล้เคียง:

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>
}

คุณคิดถูกที่คอมไพเลอร์สามารถเดาได้ง่าย แต่มันไม่ได้อยู่ในมาตรฐานหรือ C ++ 0x เท่าที่ฉันรู้ดังนั้นคุณจะต้องรออย่างน้อยอีก 10 ปี (มาตรฐาน ISO คงที่อัตราการหมุนเวียน) ก่อนที่ผู้ให้บริการคอมไพเลอร์จะเพิ่มคุณสมบัตินี้

ลองดูปัญหาที่อ้างอิงถึงคลาสที่ทุกคนควรรู้จักด้วย - std :: vector

ประการแรกการใช้เวกเตอร์โดยทั่วไปคือการใช้ตัวสร้างที่ไม่มีพารามิเตอร์:

vector <int> v;

ในกรณีนี้ไม่สามารถทำการอนุมานได้อย่างชัดเจน

การใช้งานทั่วไปครั้งที่สองคือการสร้างเวกเตอร์ขนาดล่วงหน้า:

vector <string> v(100);

ที่นี่หากใช้การอนุมาน:

vector v(100);

เราได้เวกเตอร์ของ ints ไม่ใช่สตริงและน่าจะไม่ได้ขนาด!

สุดท้ายให้พิจารณาตัวสร้างที่รับพารามิเตอร์หลายตัว - ด้วย "การอนุมาน":

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

ควรใช้พารามิเตอร์ใดในการอนุมาน เราต้องการวิธีบอกคอมไพเลอร์ว่าควรเป็นคอมไพเลอร์ตัวที่สอง

ด้วยปัญหาเหล่านี้สำหรับคลาสที่เรียบง่ายเหมือนเวกเตอร์จึงง่ายต่อการดูว่าทำไมจึงไม่ใช้การอนุมาน

การทำให้ ctor เป็นเทมเพลตตัวแปรสามารถมีได้เพียงรูปแบบเดียวแต่ ctors ต่างกัน:

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;         
}

ดู? เราไม่สามารถมีสมาชิก Variable :: data ได้หลายตัว

ดูการหักอาร์กิวเมนต์เทมเพลต C ++สำหรับข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้