function templates doesn't support default template parameters?

Collapse
This topic is closed.
X
X
Collapse
 
  • Page of 1
  • Time
  • Show
Clear All
new posts
Previous template Next
  • William Xu
    #1

    function templates doesn't support default template parameters?

    Compiling:

    template <class T = int>
    T foo(const T& t)
    {}

    int main(int argc, char *argv[])
    {}

    gcc complains:

    ,----
    | /Users/william/repo/helloworlds/foo.cpp:2: error: default template
    | arguments may not be used in function templates
    `----

    But I find in "TC++PL(3rd , special edition)" P.340, Bjarne is giving
    function templates with default template parameters as examples.

    If current standard doesn't support it, what is the reason here?

    --
    William
    Tags: None
    • =?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=
      #2
      Re: function templates doesn't support default template parameters?

      On 2008-06-01 16:29, William Xu wrote:
      Compiling:
      >
      template <class T = int>
      T foo(const T& t)
      {}
      >
      int main(int argc, char *argv[])
      {}
      >
      gcc complains:
      >
      ,----
      | /Users/william/repo/helloworlds/foo.cpp:2: error: default template
      | arguments may not be used in function templates
      `----
      >
      But I find in "TC++PL(3rd , special edition)" P.340, Bjarne is giving
      function templates with default template parameters as examples.
      >
      If current standard doesn't support it, what is the reason here?
      It is not supported in the current standard (14.1 §9), I do not know why.

      --
      Erik Wikström

        Comment

        • Kai-Uwe Bux
          #3
          Re: function templates doesn't support default template parameters?

          Erik Wikström wrote:
          On 2008-06-01 16:29, William Xu wrote:
          >Compiling:
          >>
          > template <class T = int>
          > T foo(const T& t)
          > {}
          >>
          > int main(int argc, char *argv[])
          > {}
          >>
          >gcc complains:
          >>
          >,----
          >| /Users/william/repo/helloworlds/foo.cpp:2: error: default template
          >| arguments may not be used in function templates
          >`----
          >>
          >But I find in "TC++PL(3rd , special edition)" P.340, Bjarne is giving
          >function templates with default template parameters as examples.
          >>
          >If current standard doesn't support it, what is the reason here?
          >
          It is not supported in the current standard (14.1 §9), I do not know why.
          I wonder what difference one should expect from

          template < typename T = int >
          T foo ( T const & arg );

          and

          template < typename T >
          T foo ( T const & arg );

          How would you use the default type? The type T would be deduced from the
          argument anyway, wouldn't it?


          Best

          Kai-Uwe Bux

            Comment

            • William Xu
              #4
              Re: function templates doesn't support default template parameters?

              Kai-Uwe Bux <jkherciueh@gmx .netwrites:
              How would you use the default type? The type T would be deduced from the
              argument anyway, wouldn't it?
              Consider the following example then. What if I want the default
              comparision method to be Case_insensitiv e?

              #include <iostream>

              struct Case_insensitiv e
              {
              static bool eq(char c1, char c2) { return tolower(c1) == tolower(c2); }
              };

              struct Case_sensitive
              {
              static bool eq(char c1, char c2) { return c1 == c2; }
              };

              template <class Cmp>
              bool eq(char c1, char c2)
              {
              return Cmp::eq(c1, c2);
              }

              int main(int argc, char *argv[])
              {
              char c1 = 'h', c2 = 'H';

              /* These are okay. */
              eq<Case_insensi tive>(c1, c2) ;
              eq<Case_sensiti ve>(c1, c2);

              /* But how about this one ? */
              /* eq(c1, c2); */

              }

              --
              William

              http://williamxu.net9.org


              You know what they say -- the sweetest word in the English language is revenge.
              -- Peter Beard

                Comment

                • Kai-Uwe Bux
                  #5
                  Re: function templates doesn't support default template parameters?

                  William Xu wrote:
                  Kai-Uwe Bux <jkherciueh@gmx .netwrites:
                  >
                  >How would you use the default type? The type T would be deduced from the
                  >argument anyway, wouldn't it?
                  >
                  Consider the following example then. What if I want the default
                  comparision method to be Case_insensitiv e?
                  >
                  #include <iostream>
                  >
                  struct Case_insensitiv e
                  {
                  static bool eq(char c1, char c2) { return tolower(c1) == tolower(c2); }
                  };
                  >
                  struct Case_sensitive
                  {
                  static bool eq(char c1, char c2) { return c1 == c2; }
                  };
                  >
                  template <class Cmp>
                  bool eq(char c1, char c2)
                  {
                  return Cmp::eq(c1, c2);
                  }
                  >
                  int main(int argc, char *argv[])
                  {
                  char c1 = 'h', c2 = 'H';
                  >
                  /* These are okay. */
                  eq<Case_insensi tive>(c1, c2) ;
                  eq<Case_sensiti ve>(c1, c2);
                  >
                  /* But how about this one ? */
                  /* eq(c1, c2); */
                  >
                  }
                  Now, I can see your point.

                  On the other hand, it looks as though you want a default argument not a
                  default type:

                  #include <cctype>

                  bool case_insensitiv e ( char c1, char c2 ) {
                  return ( std::tolower(c1 ) == std::tolower(c2 ) );
                  }

                  bool case_sensitive ( char c1, char c2 ) {
                  return ( c1 == c2 );
                  }

                  typedef bool(* char_compare )(char,char);

                  bool eq ( char c1, char c2, char_compare comp = &case_sensit ive ) {
                  return ( comp( c1, c2 ) );
                  }

                  int main ( void ) {
                  eq( 'c', 'h' );
                  }


                  Then again, I am not at all sure whether it is a good idea to have a default
                  in this case. I generally do not like magic hiding somewhere. Sooner or
                  later it is going to bite you. From that point of view, I prefer the
                  verbose version

                  eq< case_sensitive >( c1, c2 );

                  to

                  eq( c1, c2 );



                  Best

                  Kai-Uwe Bux

                    Comment

                    • James Kanze
                      #6
                      Re: function templates doesn't support default template parameters?

                      On Jun 1, 4:46 pm, Erik Wikström <Erik-wikst...@telia. comwrote:
                      On 2008-06-01 16:29, William Xu wrote:
                      Compiling:
                      template <class T = int>
                      T foo(const T& t)
                      {}
                      int main(int argc, char *argv[])
                      {}
                      gcc complains:
                      But I find in "TC++PL(3rd , special edition)" P.340, Bjarne
                      is giving function templates with default template
                      parameters as examples.
                      That surprises me a bit (but someone walked off with my copy of
                      the 3rd edition, so I can't verify it).
                      If current standard doesn't support it, what is the reason
                      here?
                      It is not supported in the current standard (14.1 §9), I do
                      not know why.
                      Probably because originally, function template arguments could
                      only be deduced, not explicitly specified, and a defauld
                      argument doesn't make sense in that case. For that matter,
                      given the original poster's example, when would the default
                      argument be used?

                      --
                      James Kanze (GABI Software) email:james.kan ze@gmail.com
                      Conseils en informatique orientée objet/
                      Beratung in objektorientier ter Datenverarbeitu ng
                      9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

                        Comment

                        • Eric Pruneau
                          #7
                          Re: function templates doesn't support default template parameters?


                          "James Kanze" <james.kanze@gm ail.coma écrit dans le message de news:
                          ffdcd885-47d4-4b5f-86e1-e9496608bb89...l egroups.com...
                          On Jun 1, 4:46 pm, Erik Wikström <Erik-wikst...@telia. comwrote:
                          On 2008-06-01 16:29, William Xu wrote:
                          Compiling:
                          template <class T = int>
                          T foo(const T& t)
                          {}
                          int main(int argc, char *argv[])
                          {}
                          gcc complains:
                          But I find in "TC++PL(3rd , special edition)" P.340, Bjarne
                          is giving function templates with default template
                          parameters as examples.
                          That surprises me a bit (but someone walked off with my copy of
                          the 3rd edition, so I can't verify it).
                          If current standard doesn't support it, what is the reason
                          here?
                          It is not supported in the current standard (14.1 §9), I do
                          not know why.
                          Probably because originally, function template arguments could
                          only be deduced, not explicitly specified, and a defauld
                          argument doesn't make sense in that case. For that matter,
                          given the original poster's example, when would the default
                          argument be used?

                          --

                          From C++ Templates (Vandevoorde, Josuttis)

                          "When templates were originally added to the C++ language, explicit function
                          template arguments were not a valid construct. [...] Since then, however, it
                          is possible to specify explicitle function template arguments that cannot be
                          deduced. "

                          So the following should compile...

                          template <typename T1, typename T2 = int>
                          T2 count (T1 const& x);

                          Cause T2 cannot be deduced since it is the return parameter. However I tried
                          with intel c++ 9.1 and VS 2003 compilers and they give me an error...


                          --------
                          Eric Pruneau


                            Comment

                            Previous template Next
                            Working...