fork download
copy 
  1. #include <vector>
  2. #include <iostream>
  3.  
  4. /////////////////////////////////////////////////////////////////////////////
  5. // Data struct
  6. /////////////////////////////////////////////////////////////////////////////
  7.  
  8. struct point { 
  9.     point(int x, int y):x(x), y(y) {} 
  10.     int x, y ;
  11. } ;
  12.  
  13. /////////////////////////////////////////////////////////////////////////////
  14. // Seperated x & y implementation
  15. /////////////////////////////////////////////////////////////////////////////
  16.  
  17. int max_x ( std::vector<point>& v ) {
  18.         int result = v[0].x ;
  19.         for ( std::vector<point>::size_type i = 1; i != v.size(); ++i )
  20.                 if(v[i].x > result)
  21.                         result = v[i].x ;
  22.         return result ;
  23. }
  24.  
  25. int max_y ( std::vector<point>& v ) {
  26.         int result = v[0].y ;
  27.         for ( std::vector<point>::size_type i = 1; i != v.size(); ++i )
  28.                 if(v[i].y > result)
  29.                         result = v[i].y ;
  30.         return result ;
  31. }
  32.  
  33. /////////////////////////////////////////////////////////////////////////////
  34. // Access function
  35. /////////////////////////////////////////////////////////////////////////////
  36.  
  37. int& access(point& p, const int index) {
  38.     return index == 0 ? p.x : p.y ;
  39. }
  40.  
  41. int max ( std::vector<point>& v, const int index) {
  42.         int result = access(v[0], index) ;
  43.         for ( std::vector<point>::size_type i = 1; i != v.size(); ++i )
  44.                 if(access(v[i], index) > result)
  45.                         result = access(v[i], index) ;
  46.         return result ;
  47. }
  48.  
  49. /////////////////////////////////////////////////////////////////////////////
  50. // Specialized access function template
  51. /////////////////////////////////////////////////////////////////////////////
  52.  
  53. template < int N > int& access(point& p) ;
  54. template <> int& access<0>(point& p) { return p.x ; }
  55. template <> int& access<1>(point& p) { return p.y ; }
  56.  
  57. template < int N >
  58. int max ( std::vector<point>& v) {
  59.         int result = access<N>(v[0]) ;
  60.         for ( std::vector<point>::size_type i = 1; i != v.size(); ++i )
  61.                 if(access<N>(v[i]) > result)
  62.                         result = access<N>(v[i]) ;
  63.         return result ;
  64. }
  65.  
  66. /////////////////////////////////////////////////////////////////////////////
  67. // Pointer-to-member
  68. /////////////////////////////////////////////////////////////////////////////
  69.  
  70. int max ( std::vector<point>& v, int point::*m )
  71. {
  72.     int result = v[0].*m ;
  73.         for ( std::vector<point>::size_type i = 1; i != v.size(); ++i )
  74.                 if(v[i].*m > result)
  75.                         result = v[i].*m ;
  76.         return result ;
  77. }
  78.  
  79. template < typename T >
  80. int max ( std::vector<point>& v, T m )
  81. {
  82.     int result = v[0].*m ;
  83.         for ( std::vector<point>::size_type i = 1; i != v.size(); ++i )
  84.                 if(v[i].*m > result)
  85.                         result = v[i].*m ;
  86.         return result ;
  87. }
  88.  
  89. /////////////////////////////////////////////////////////////////////////////
  90. // main
  91. /////////////////////////////////////////////////////////////////////////////
  92.  
  93. int main()
  94. {
  95.     std::vector<point> v ;
  96.     v.push_back(point(1, 9));
  97.     v.push_back(point(2, 8));
  98.     v.push_back(point(3, 7));
  99.     v.push_back(point(4, 6));
  100.     v.push_back(point(5, 5));
  101.  
  102.     // Seperated x & y implementation
  103.     std::cout << max_x(v) << std::endl ;
  104.     std::cout << max_y(v) << std::endl ;
  105.  
  106.     // access function
  107.     std::cout << max(v, 0) << std::endl ;
  108.     std::cout << max(v, 1) << std::endl ;
  109.  
  110.     // Specialized access function template
  111.     std::cout << max<0>(v) << std::endl ;
  112.     std::cout << max<1>(v) << std::endl ;
  113.  
  114.     // Pointer-to-member
  115.     std::cout << max(v, &point::x) << std::endl ;
  116.     std::cout << max(v, &point::y) << std::endl ;
  117. }
Success #stdin #stdout 0.01s 2816KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
5
9
5
9
5
9
5
9
https://ideone.com/qLKXX
language:
C++ (gcc 8.3)
created:
13 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!