Home | History | Annotate | Line # | Download | only in gdb.cp 
      1 /* This testcase is part of GDB, the GNU debugger.
      2 
      3    Copyright 1998-2024 Free Software Foundation, Inc.
      4 
      5    This program is free software; you can redistribute it and/or modify
      6    it under the terms of the GNU General Public License as published by
      7    the Free Software Foundation; either version 3 of the License, or
      8    (at your option) any later version.
      9 
     10    This program is distributed in the hope that it will be useful,
     11    but WITHOUT ANY WARRANTY; without even the implied warranty of
     12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     13    GNU General Public License for more details.
     14 
     15    You should have received a copy of the GNU General Public License
     16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
     17 
     18 /* Rvalue references overload tests for GDB, based on overload.cc.  */
     19 
     20 #include <stddef.h>
     21 #include <utility>
     22 
     23 class foo;
     24 
     25 typedef foo &foo_lval_ref;
     26 typedef foo &&foo_rval_ref;
     27 
     28 class foo
     29 {
     30 public:
     31   foo ();
     32   foo (foo_lval_ref);
     33   foo (foo_rval_ref);
     34   ~foo ();
     35 
     36   int overload1arg (foo_lval_ref);
     37   int overload1arg (foo_rval_ref);
     38   int overloadConst (const foo &);
     39   int overloadConst (const foo &&);
     40 };
     41 
     42 void
     43 marker1 ()
     44 {
     45 }
     46 
     47 static int
     48 f (int &x)
     49 {
     50   return 1;
     51 }
     52 
     53 static int
     54 f (const int &x)
     55 {
     56   return 2;
     57 }
     58 
     59 static int
     60 f (int &&x)
     61 {
     62   return 3;
     63 }
     64 
     65 static int
     66 g (int &&x)
     67 {
     68   return x;
     69 }
     70 
     71 int
     72 main ()
     73 {
     74   foo foo_rr_instance1;
     75   foo arg;
     76   int i = 0;
     77   const int ci = 0;
     78 
     79   // result = 1 + 2 + 3 + 3 = 9
     80   int result = f (i) + f (ci) + f (0) + f (std::move (i));
     81 
     82   /* Overload resolution below requires both a CV-conversion
     83      and reference conversion.  */
     84   int test_const // = 3
     85     = foo_rr_instance1.overloadConst (arg);
     86 
     87   /* The statement below is illegal: cannot bind rvalue reference of
     88      type 'int&&' to lvalue of type 'int'.
     89 
     90      result = g (i); */
     91   result = g (5); // this is OK
     92 
     93   marker1 (); // marker1-returns-here
     94   return result;
     95 }
     96 
     97 foo::foo  ()                       {}
     98 foo::foo  (foo_lval_ref afoo)      {}
     99 foo::foo  (foo_rval_ref afoo)      {}
    100 foo::~foo ()                       {}
    101 
    102 /* Some functions to test overloading by varying one argument type. */
    103 
    104 int foo::overload1arg (foo_lval_ref arg)           { return 1; }
    105 int foo::overload1arg (foo_rval_ref arg)           { return 2; }
    106 int foo::overloadConst (const foo &arg)            { return 3; }
    107 int foo::overloadConst (const foo &&arg)           { return 4; }
    108