Re: c++/9602: falsely concludes that function defined within classbody is virtual and abstract, therefore compiler fails to allow classinstantiation with pure virtual function error.

[Victor Isaac Lesk <vil at rccp dot tsukuba dot ac dot jp>]

On 6 Feb 2003 bangerth@dealii.org wrote:

> Synopsis: falsely concludes that function defined within class body is virtual and abstract, therefore compiler fails to allow class instantiation with pure virtual function error.
> 
> State-Changed-From-To: open->feedback
> State-Changed-By: bangerth
> State-Changed-When: Thu Feb  6 23:23:46 2003
> State-Changed-Why:
>     For some reason, the testcase didn't make it into the
>     report. Can you try to send it to me so that I can attach
>     it to the report?
>     
>     Thanks
>       Wolfgang
> 
> http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=9602
> 

Here it is:
//////////////
#include<iostream>
#include<stdio.h>

using namespace std;

template<typename t>
class Pair
{
private:
protected:
public:
  t first;
  t second;
  t&last;

  Pair();
  Pair(t,t);
  Pair(const string);

  void set_Pair(const t,const t);
  void set(const t,const t);
  void set_First(const t);
  void set_Second(const t);
  void set_Last(const t);
  t get_First(void)const;
  t get_Second(void)const;
  t get_Last(void)const;
  bool contains(const t)const;
  bool includes(const t)const;

  void display(void)const;

  void operator=(const Pair<t>);

  template<typename l>operator class Pair<l>(void)const;

  friend ostream&operator<<(ostream&a,const class Pair<t>&r)
    {
      return a<<r.first<<SPC<<r.second;
    }
  friend istream&operator>>(istream&a,class Pair<t>&r)
    {
      return a>>r.first>>r.second;
    }
};

template<typename t>
ostream&
operator<<(ostream&,const Pair<t>&);

template<typename t>
istream&
operator>>(istream&,Pair<t>&);


template<typename t>
Pair<t>::
Pair():
  last(second)
{
}

template<typename t>
Pair<t>::
Pair(const string s):
  last(second)
{
}

template<typename t>
Pair<t>::
Pair(t a,t b):
  last(second)
{
  set_Pair(a,b);
}

template<typename t>
t
Pair<t>::
get_First(void)const
{
  return first;
}

template<typename t>
t
Pair<t>::
get_Second(void)const
{
  return second;
}

template<typename t>
t
Pair<t>::
get_Last(void)const
{
  return last;
}

template<typename t>
void
Pair<t>::
set(t l,t h)
{
  first=l;second=h;
}

template<typename t>
void
Pair<t>::
operator=(const Pair<t> pair)
{
  set_First(pair.first);
  set_Second(pair.second);
}

template<typename t>
void
Pair<t>::
set_Pair(t l,t h)
{
  set(l,h);
}

template<typename t>
void
Pair<t>::
set_First(const t a)
{
  first=a;
}

template<typename t>
void
Pair<t>::
set_Second(const t a)
{
  second=a;
}

template<typename t>
bool
Pair<t>::
contains(const t a)const
{
  return (a==first || a==second);
}

template<typename t>
bool
Pair<t>::
includes(const t a)const
{
  return contains(a);
}

template<typename t>
void
Pair<t>::
display(void)const
{
  cout<<LPR<<first<<COM<<second<<RPR;
}

template<typename t>template<typename l>
Pair<t>::
operator Pair<l>(void)const
{
  return Pair<l>(l(first),l(second));
}

int main(const int,const char*const*const)
{
  Pair<int> pair1;



  return 0;
}