zoukankan      html  css  js  c++  java
  • c++11 : Local and Unnamed Types as Template Arguments

     

     

    In N2402, Anthony Williams proposes that local types, and unnamed types be usable as template arguments. At the February 2008 (Bellevue) meeting, the Core working group supported the use of local types but was concerned about unnamed types. In addition, the WG did not support the mechanism used to accomplish this change in N2402.

    I discussed the unnamed type issue with Anthony Williams and others. Use of unnamed types as template arguments was considered a useful facility and does not seem to present any particular implementation issues. In particular, it is fairly common practice to use unnamed enumerations in header files. Consequently, unnamed types have been retained in this proposal. Note that a namespace scope unnamed enumeration in one translation unit is distinct from one in another translation unit. So in the example below, x and y are initalized by two different instances of f

    file1.c: template <class T> int f(T t); enum {e1}; int x = f(e1); file2.c: template <class T> int f(T t); enum {e1}; int y = f(e1);

    N2402 makes local types and unnamed types usable as template arguments by giving them linkage. As mentioned above, the Core Working Group did not favor this solution. This document provides drafting to allow local and unnamed types to be used as template arguments by revising the rules for template arguments to permit such types.

    Working Paper Changes

    Change 3.5 [basic.link] paragraph 8 as follows:

    A type without linkage shall not be used as the type of a variable or function with linkage, unless
    • the variable or function has extern "C" linkage., or
    • the type without linkage was named using a dependent type (14.6.2.1).

    Delete the following sentence from 3.5 [basic.link] paragraph 8:

    This implies that names with no linkage cannot be used as template arguments (14.3).

    Add the following example after paragraph 8:

    [ Example: template <class T> struct A { // in A<X>, the following is allowed because the type with no linkage // X is named using template parameter T. friend void f(A, T){} }; template <class T> void g(T t) { A<T> at; f(at, t); } int main() { class X {} x; g(x); } -- end example]

    In 14.3.1 [temp.arg.type] paragraph 2 remove the following text:

    A type without linkage (3.5) shall not be used as a template argument for a template type parameter.

    Replace the example in paragraph 2 with the following:

    [ Example: template <class T> class X { }; template <class T> void f(T t) { } struct {} unnamed_obj; void f() { struct A { }; enum { e1 }; typedef struct {} B; B b; X<A> x1; // OK X<A*> x2; // OK X<B> x3; // OK f(e1); // OK f(unnamed_obj); // OK f(b); // OK } -- end example]

    End of document.

  • 相关阅读:
    错误记录 git pull
    关于file_operations结构体
    20180911-Java实例01
    20180910-Java 文档注释
    20180907-Java Applet基础
    Elastic Stack生态圈
    关于我和本博客
    雨后的春日清晨
    charles 安装https证书
    css3不同文字大小底部对齐的完美解决方案
  • 原文地址:https://www.cnblogs.com/lvdongjie/p/4489922.html
Copyright © 2011-2022 走看看