root/test/manual/cedet/tests/testpolymorph.cpp

DEFINITIONS

1. pt_func1
2. pm_func
3. pm_func
4. pm_func
5. pm_func
6. pm_meth
7. pm_meth
8. pm_meth
9. pm_meth
10. doSomething
11. doSomething
12. doSomething
13. doSomethingElse
14. doSomethingElse
15. doSomethingCompletelyDifferent
16. doSomething
17. doSomethingElse
18. doSomething
19. doSomethingElse
20. doSomething
21. doSomethingElse
22. doNothing

     1 /** testpolymorph.cpp --- A sequence of polymorphism examples.
     2  *
     3  * Copyright (C) 2009-2023 Free Software Foundation, Inc.
     4  *
     5  * Author: Eric M. Ludlam <zappo@gnu.org>
     6  *
     7  * This file is part of GNU Emacs.
     8  *
     9  * GNU Emacs is free software: you can redistribute it and/or modify
    10  * it under the terms of the GNU General Public License as published by
    11  * the Free Software Foundation, either version 3 of the License, or
    12  * (at your option) any later version.
    13  *
    14  * GNU Emacs is distributed in the hope that it will be useful,
    15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17  * GNU General Public License for more details.
    18  *
    19  * You should have received a copy of the GNU General Public License
    20  * along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
    21  */
    22 
    23 #include <cmath>
    24 
    25 // Test 1 - Functions with prototypes
    26 namespace proto {
    27 
    28   int pt_func1(int arg1);
    29   int pt_func1(int arg1) {
    30     return 0;
    31   }
    32 
    33 }
    34 
    35 // Test 2 - Functions with different arg lists.
    36 namespace fcn_poly {
    37 
    38   int pm_func(void) {
    39     return 0;
    40   }
    41   int pm_func(int a) {
    42     return a;
    43   }
    44   int pm_func(char a) {
    45     return int(a);
    46   }
    47   int pm_func(double a) {
    48     return int(floor(a));
    49   }
    50 
    51 }
    52 
    53 // Test 3 - Methods with different arg lists.
    54 class meth_poly {
    55 public:
    56   int pm_meth(void) {
    57     return 0;
    58   }
    59   int pm_meth(int a) {
    60     return a;
    61   }
    62   int pm_meth(char a) {
    63     return int(a);
    64   }
    65   int pm_meth(double a) {
    66     return int(floor(a));
    67   }
    68 
    69 };
    70 
    71 // Test 4 - Templates with partial specifiers.
    72 namespace template_partial_spec {
    73   template <typename T> class test
    74   {
    75   public:
    76     void doSomething(T t) { };
    77   };
    78 
    79   template <typename T> class test<T *>
    80   {
    81   public:
    82     void doSomething(T* t) { };
    83   };
    84 }
    85 
    86 // Test 5 - Templates with full specialization which may or may not share
    87 // common functions.
    88 namespace template_full_spec {
    89   template <typename T> class test
    90   {
    91   public:
    92     void doSomething(T t) { };
    93     void doSomethingElse(T t) { };
    94   };
    95 
    96   template <> class test<int>
    97   {
    98   public:
    99     void doSomethingElse(int t) { };
   100     void doSomethingCompletelyDifferent(int t) { };
   101   };
   102 }
   103 
   104 // Test 6 - Dto., but for templates with multiple parameters.
   105 namespace template_multiple_spec {
   106   template <typename T1, typename T2> class test
   107   {
   108   public:
   109     void doSomething(T1 t) { };
   110     void doSomethingElse(T2 t) { };
   111   };
   112 
   113   template <typename T2> class test<int, T2>
   114   {
   115   public:
   116     void doSomething(int t) { };
   117     void doSomethingElse(T2 t) { };
   118   };
   119 
   120   template <> class test<float, int>
   121   {
   122   public:
   123     void doSomething(float t) { };
   124     void doSomethingElse(int t) { };
   125     void doNothing(void) { };
   126   };
   127 }
   128 
   129 
   130 // End of polymorphism test file.