"const <anonymous>**" and "<unknown type>" errors while compiling

Discussion in 'C++' started by H. S., Mar 20, 2005.

  1. H. S.

    H. S. Guest

    Hi,

    I am trying to compile these set of C++ files and trying out class
    inheritence and function pointers. Can anybody shed some light why my
    compiler is not compiling them and where I am going wrong?

    I am using g++ (GCC) 3.3.5 on a Debian Sarge system. The compiler complains:
    //****************************
    //**************************** Compiler output starts ***********
    cd /home/red/tmp/testprogs/
    time make
    g++ -gstabs -ansi -Wall -c -I./ hstestprog.cc -o hstestprog.o
    derivedclass2.h: In constructor `
    DerivedClass2<FLOAT>::DerivedClass2(hsOperation<FLOAT>&) [with FLOAT =
    double]':
    hstestprog.cc:34: instantiated from `int CallingFunc(FLOAT, FLOAT*)
    [with FLOAT = double]'
    hstestprog.cc:19: instantiated from here
    derivedclass2.h:19: error: no matching function for call to `
    DerivedClass1<double, hsOperation<double> >::DerivedClass1(const
    <anonymous>**)'
    derivedclass1.h:12: error: candidates are: DerivedClass1<double,
    hsOperation<double> >::DerivedClass1(const DerivedClass1<double,
    hsOperation<double> >&)
    derivedclass1.h:22: error: DerivedClass1<FLOAT,
    FOP>::DerivedClass1(FOP*, void (FOP::*)(FLOAT*, FLOAT*)) [with FLOAT =
    double, FOP = hsOperation<double>]
    hstestprog.cc:34: instantiated from `int CallingFunc(FLOAT, FLOAT*)
    [with FLOAT = double]'
    hstestprog.cc:19: instantiated from here
    derivedclass2.h:21: error: no matching function for call to `
    DerivedClass2<double>::vcVirtualFunc(hsOperation<double>*, <unknown
    type>)'
    virtualclass.h:21: error: candidates are: void VirtualClass<FLOAT, TYPE,
    FOP>::vcVirtualFunc(FOP*, void (FOP::*)(TYPE*, TYPE*)) [with FLOAT =
    double,
    TYPE = double, FOP = hsOperation<double>]
    make: *** [hstestprog.o] Error 1
    //**************************** Compiler output Ends ***********
    //****************************



    The source files are given below.

    Thanks,
    ->HS

    PS: Here are the source files I am trying to compile, 5 in all:

    //******** hsoperation.h ***************** %< %< %< %<
    #ifndef _HSOPERATION_H_
    #define _HSOPERATION_H_

    #include "virtualclass.h"

    /*! This header file defines a template class which provides an
    overloaded function that does some operation. This class mainly sets up
    some data and provides the method to operate on that data. This class
    can provide various methods to operate differently on the data.*/

    template<class TYPE>
    class hsOperation{
    public:
    hsOperation(TYPE* x, TYPE* y);
    void vOperationAdd(TYPE* x, TYPE* y);
    void GetSolution(TYPE* R);
    TYPE Result;

    TYPE X,Y;
    };

    template <class TYPE>
    inline hsOperation<TYPE>::
    hsOperation(TYPE* x, TYPE* y){
    X = *x;
    Y = *y;
    }

    template <class TYPE>
    inline void hsOperation<TYPE>::
    vOperationAdd(TYPE* x, TYPE* y)
    {
    Result = (*x) + (*y);
    }

    template <class TYPE>
    inline void hsOperation<TYPE>::GetSolution(TYPE* R)
    {
    *R = Result;
    }

    #endif //_HSOPERATION_H_
    /////////// hsoperation.h ////////////// %< %< %< %<


    //******** hsoperation.cc ************** %< %< %< %<

    #include <cstddef>
    #include <iostream>

    #include "hsoperation.h"
    #include "derivedclass2.h"
    template <class FLOAT>
    int CallingFunc(FLOAT N, FLOAT* Result);

    int main()
    {
    //hsOperation<int> hsOP;
    int i,j;
    double dN, dR;
    i = 2;
    j = 3;
    //hsOP.vOperation(&i,&j);
    //std::cout << "Result: " << hsOP.Result << std::endl;

    CallingFunc<double>(dN, &dR);
    }


    template <class FLOAT>
    int CallingFunc(FLOAT N, FLOAT* pResult)
    {

    double di, dj;
    di=3.5;
    dj=10.0;
    //initialize certain values here to operated upon later
    hsOperation<FLOAT> matrix(&di,&dj);

    //now operate on the initialized values
    DerivedClass2<FLOAT> prob(matrix);

    //now get the result of the operation
    prob.Solution(pResult);
    return 0;

    } // real nonsymmetric standard problem, values and vectors, regular mode.
    /////////// hsoperation.cc //////////////// %< %< %< %<


    //******** derivedclass1.h *************** %< %< %< %<
    #ifndef _DERIVEDCLASS1_H_
    #define _DERIVEDCLASS1_H_

    #include "virtualclass.h"


    /*! This is the first derived class, that corresponds to ARNonSymStdEig
    in arsnsym.h
    */

    template<class FLOAT, class FOP>
    class DerivedClass1:
    public virtual VirtualClass<FLOAT, FLOAT, FOP> {

    public:
    DerivedClass1(FOP* objOPp, void(FOP::* MultOPxp)(FLOAT[], FLOAT[]));

    };


    template<class FLOAT, class FOP>
    inline DerivedClass1<FLOAT, FOP>::
    DerivedClass1(FOP* objOPp, void(FOP::* MultOPxp)(FLOAT[], FLOAT[])){
    vcVirtualFunc(ObjOPp,MultOPxp);
    }

    #endif //_DERIVEDCLASS1_H_
    /////////// derivedclass1.h ///////////////// %< %< %< %<


    //******** derivedclass2.h ***************** %< %< %< %<
    #ifndef _DERIVEDCLASS2_H_
    #define _DERIVEDCLASS2_H_

    #include "hsoperation.h"
    #include "derivedclass1.h"

    template<class FLOAT>
    class DerivedClass2:
    public virtual DerivedClass1<FLOAT, hsOperation<FLOAT> > {

    public:
    DerivedClass2(hsOperation<FLOAT>& A);
    void Solution(FLOAT* pR);

    };

    template<class FLOAT>
    inline DerivedClass2<FLOAT>::
    DerivedClass2(hsOperation<FLOAT>& A){

    vcVirtualFunc(&A, hsOperation<FLOAT>::vOperationAdd);
    }


    template<class FLOAT>
    inline void DerivedClass2<FLOAT>::
    Solution(FLOAT* pR){

    //*pR = Result;
    }


    #endif //_DERIVEDCLASS2_H_
    /////////// derivedclass2.h ////////////////// %< %< %< %<


    //******** virtualclass.h ****************** %< %< %< %<
    #ifndef _VIRTUALCLASS_H_
    #define _VIRTUALCLASS_H_


    /*! This is the Virtual class which will have the virtual function*/

    template <class FLOAT, class TYPE, class FOP>
    class VirtualClass{
    public:

    typedef void (FOP::* TypeOPx)(TYPE[], TYPE[]);

    FOP* objOP;// Object that has MultOPx as a member function.
    TypeOPx MultOPx;// Function that evaluates the product OP*x.

    virtual void vcVirtualFunc(FOP*, TypeOPx);
    };

    template <class FLOAT, class TYPE, class FOP>
    void VirtualClass<FLOAT, TYPE, FOP>::
    vcVirtualFunc(FOP* objOPp, void (FOP::* MultOPxp)(TYPE[],TYPE[])){

    objOP = objOPp;
    MultOPx = MultOPxp;
    }


    #endif // _VIRTUALCLASS_H_
    /////////// virtualclass.h /////////////////// %< %< %< %<


    //******** Makefile ************************* %< %< %< %<

    PROGRAM= hstestprog
    OBJS= hstestprog.o


    CXX = g++
    CXX_FLAGS = -gstabs -ansi -Wall -c
    CPPFLAGS= -I./

    #put paths and names of libraries
    LIBS=

    #list other object files's pathnames here
    OTHEROBS=

    #lnker stuff
    LD = g++
    LDFLAGS = $(LIBS) -lm

    ####################doxygen document generation stuff####################
    #config file to be used to procude the documentation
    DOXFILE=
    #directory created by doxygen. As specified in the dox config file.
    DOXOUTDIR=
    #program to produce the documentation
    DOXPROG=doxygen

    RM = rm -f
    RMDIR= rm -rf

    $(PROGRAM) : $(OBJS)
    $(LD) $(LDFLAGS) $^ -o $@ $(LDFLAGS) $(OTHEROBS)

    #testtnt.o:testtnt.cc
    hstestprog.o: hstestprog.cc hsoperation.h virtualclass.h derivedclass1.h
    derivedclass2.h


    #specify the rule
    %.o : %.cc
    $(CXX) $(CXX_FLAGS) $(CPPFLAGS) $< -o $@


    #make the documentation
    ####html: *.cc *.h $(DOXFILE)
    #### $(RMDIR) $(DOXOUTDIR)
    #### $(DOXPROG) $(DOXFILE)
    #### echo "docs made"
    ####$(DOXFILE):
    #### $(DOXPROG) -g $(DOXFILE)


    cleanALL: cleanall
    $(RMDIR) $(DOXOUTDIR)

    #clean up operations
    prune:
    $(RM) *~
    clean: prune
    $(RM) -f $(OBJS)

    cleanall: clean
    $(RM) -f $(PROGRAM) *.o *~
    /////////// Makefile ////////////////////////// %< %< %< %<


    --
    Please remove the underscores ( the '_' symbols) from my email address
    to obtain the correct one. Apologies, but the fudging is to remove spam.
    H. S., Mar 20, 2005
    #1
    1. Advertising

  2. Hi,

    {please try to strip the code down some more next time, that includes
    combining everything into a single source file, and it's nice to somehow
    mark the lines of code that correspond to the error messages.}

    H. S. schrieb:
    >
    > Hi,
    >
    > I am trying to compile these set of C++ files and trying out class
    > inheritence and function pointers. Can anybody shed some light why my
    > compiler is not compiling them and where I am going wrong?
    >
    > I am using g++ (GCC) 3.3.5 on a Debian Sarge system. The compiler
    > complains:


    > derivedclass2.h: In constructor `
    > DerivedClass2<FLOAT>::DerivedClass2(hsOperation<FLOAT>&) [with FLOAT =
    > double]':
    > hstestprog.cc:34: instantiated from `int CallingFunc(FLOAT, FLOAT*)
    > [with FLOAT = double]'
    > hstestprog.cc:19: instantiated from here
    > derivedclass2.h:19: error: no matching function for call to `
    > DerivedClass1<double, hsOperation<double> >::DerivedClass1(const
    > <anonymous>**)'
    > derivedclass1.h:12: error: candidates are: DerivedClass1<double,
    > hsOperation<double> >::DerivedClass1(const DerivedClass1<double,
    > hsOperation<double> >&)


    DerivedClass1< ... > has these ctors:
    // Your user-defined one
    DerivedClass1(FOP* objOPp, void(FOP::* MultOPxp)(FLOAT[], FLOAT[]));
    // Compiler-generated cctor
    DerivedClass1(const DerivedClass1&);

    That's the candidates listed in the output above.
    Now DerivedClass2's ctor looks like this:

    template<class FLOAT>
    inline DerivedClass2<FLOAT>::
    DerivedClass2(hsOperation<FLOAT>& A){
    vcVirtualFunc(&A, &hsOperation<FLOAT>::vOperationAdd); // see below
    }

    As it doesn't include a base initializer, the compiler has no choice but
    to require a default ctor for DerivedClass1, which doesn't exist.
    That's the 1st error (don't ask me where it gets the <anonymous>**
    from). Basically, your ctor above is equivalent to this one:

    template<class FLOAT>
    inline DerivedClass2<FLOAT>::
    DerivedClass2(hsOperation<FLOAT>& A) : DerivedClass1<FLOAT>(){
    vcVirtualFunc(&A, &hsOperation<FLOAT>::vOperationAdd); // see below
    }

    Which of course can't work.

    > derivedclass1.h:22: error: DerivedClass1<FLOAT,
    > FOP>::DerivedClass1(FOP*, void (FOP::*)(FLOAT*, FLOAT*)) [with FLOAT =
    > double, FOP = hsOperation<double>]
    > hstestprog.cc:34: instantiated from `int CallingFunc(FLOAT, FLOAT*)
    > [with FLOAT = double]'
    > hstestprog.cc:19: instantiated from here
    > derivedclass2.h:21: error: no matching function for call to `
    > DerivedClass2<double>::vcVirtualFunc(hsOperation<double>*, <unknown
    > type>)'
    > virtualclass.h:21: error: candidates are: void VirtualClass<FLOAT, TYPE,
    > FOP>::vcVirtualFunc(FOP*, void (FOP::*)(TYPE*, TYPE*)) [with FLOAT =
    > double,
    > TYPE = double, FOP = hsOperation<double>]


    When gcc mentions <unknown type>, in most cases (and yours) that's
    related to "forgetting" the & with member function pointers:

    // Wrong
    vcVirtualFunc(&A, hsOperation<FLOAT>::vOperationAdd);
    // Needs to be:
    vcVirtualFunc(&A, &hsOperation<FLOAT>::vOperationAdd);

    Two more things:

    > #ifndef _HSOPERATION_H_
    > #define _HSOPERATION_H_


    Names beginning with an underscore followed by a capital letter and
    names containing two consecutive underscores are reserved for the (C++
    language) implementation. Thus, you must not use such names in your
    source files.

    > template <class TYPE>
    > inline hsOperation<TYPE>::
    > hsOperation(TYPE* x, TYPE* y){
    > X = *x;
    > Y = *y;
    > }


    Why are you passing x and y as pointers? If they are always some int or
    float types, passing by value comes with no penalty, otherwise a (const
    as you don't modify them) reference would seem more adequate:

    template <class TYPE>
    inline hsOperation<TYPE>::
    hsOperation(const TYPE& x, const TYPE& y){
    X = x;
    Y = y;
    }

    Same for similar occurances, it also saves all those dereferencing (*)
    operators inside the function and the addressof (&) operators in the
    calling code.

    > template <class TYPE>
    > inline void hsOperation<TYPE>::GetSolution(TYPE* R)
    > {
    > *R = Result;
    > }


    Same issue, plus why "return" the result this way, when the function
    doesn't have an actual return type?

    To stick with R as an output parameter, note this time it's a non-const
    reference:

    template <class TYPE>
    inline void hsOperation<TYPE>::GetSolution(TYPE& R)
    {
    R = Result;
    }

    Or the more straightforward approach:

    template <class TYPE>
    inline const TYPE& hsOperation<TYPE>::GetSolution()
    {
    return Result;
    }

    Cheers,
    Malte
    Malte Starostik, Mar 20, 2005
    #2
    1. Advertising

  3. Malte Starostik schrieb:
    > Why are you passing x and y as pointers? If they are always some int or
    > float types, passing by value comes with no penalty, otherwise a (const
    > as you don't modify them) reference would seem more adequate:
    >
    > template <class TYPE>
    > inline hsOperation<TYPE>::
    > hsOperation(const TYPE& x, const TYPE& y){
    > X = x;
    > Y = y;
    > }


    For the sake of completeness, the preferred way to initialize members is
    an initialization list:

    template <class TYPE>
    inline hsOperation<TYPE>::
    hsOperation(const TYPE& x, const TYPE& y)
    : X(x), Y(y)
    {
    }

    This reduces the implicit default initialization followed by an explicit
    assignment to an explicit non-default initialization.

    Cheers,
    Malte
    Malte Starostik, Mar 20, 2005
    #3
  4. H. S.

    H. S. Guest

    Apparently, _Malte Starostik_, on 19/03/05 21:42,typed:
    > Hi,
    >
    > {please try to strip the code down some more next time, that includes
    > combining everything into a single source file, and it's nice to somehow
    > mark the lines of code that correspond to the error messages.}


    Yes, of course. Thanks for letting me know. Apologies for all the mess
    in my post. I was looking for some way I could post a tgz of the source
    files on the Yahoo webpage one can get on Geocities but couldn't figure
    out how to upload a .tgz :(

    This is one of my first posts on this newsgroup and I really appreciate
    your polite note. I will surely keep this in mind.


    <Some very helpful comments snipped for brevity>

    >
    > Cheers,
    > Malte



    I cannot thank you enough for your very instructive and helpful
    explanations. They not only solved my problem, but they also were
    helpful in providing many insights into class declarations and
    inheritence. You made my day! I am actually trying to compile the
    ARPACK++ library on a Linux machine using the g++ compiler I mentioned
    earlier. It seems to be quite uphill task given that the code is so old.

    Thanks once again for your help,
    ->HS

    --
    Please remove the underscores ( the '_' symbols) from my email address
    to obtain the correct one. Apologies, but the fudging is to remove spam.
    H. S., Mar 20, 2005
    #4
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Mark Goldin

    Errors, errors, errors

    Mark Goldin, Jan 17, 2004, in forum: ASP .Net
    Replies:
    2
    Views:
    923
    Mark Goldin
    Jan 17, 2004
  2. Nachiketh
    Replies:
    0
    Views:
    554
    Nachiketh
    Feb 23, 2004
  3. Michael Schmitt
    Replies:
    3
    Views:
    399
    Martin v. =?iso-8859-15?q?L=F6wis?=
    Sep 10, 2003
  4. rashmi
    Replies:
    2
    Views:
    461
    Lawrence Kirby
    Sep 20, 2005
  5. Replies:
    2
    Views:
    543
    Niklas Norrthon
    Dec 7, 2005
Loading...

Share This Page