Template implementation & compiler

Question

I want to define the getRawDataPtr() function in the Array.cpp file and I implement as below and I got 2 errors

Error 82 error C2653: 'math' : is not a class or namespace name
Error 84 error C2988: unrecognizable template declaration/definition

          //file Array.cpp
          template<typename T>
          void * const math::Array<T>::getRawDataPtr
          {
          return buffer;
          }

    //file Array.h
  #ifndef _ARRAY_
  #define _ARRAY_

  namespace math
 {

  //---------------------------------------------------------------------------------------------
  // Do NOT modify this section. For the implementation, see comment below the class declaration
  //---------------------------------------------------------------------------------------------

  /*! The Array class implements a generic two-dimensional array of elements of type T.
  */
   template <typename T>
   class Array
   {
   protected:
    //! Flat storage of the elements of the array of type T
    T * buffer;                     

    //! The width of the array (number of columns)
    unsigned int width,             

    //! The height of the array (number of rows)
                 height;            

    public:

    /*! Reports the width (columns) of the array
     *
     * \return the width.
     */
    unsigned int getWidth() const { return width; }      

    /*! Reports the height (rows) of the array
     *
     * \return the height.
     */
    unsigned int getHeight() const { return height; }    

    /*! Obtains a constant pointer to the internal data.
    *
    *  This is NOT a copy of the internal array data, but rather a pointer
    *  to the internally allocated space.
    */
    void * const getRawDataPtr();

    /*! Returns a reference to the element at the zero-based position (column x, row y).
     *
     * \param x is the zero-based column index of the array.
     * \param y is the zero-based row index of the array.
     * 
     * \return a reference to the element at position (x,y)
     */
     T & operator () (int x, int y);                      

    /*! Returns a constant reference to the element at the zero-based position (column x, row y).
    *
    * \param x is the zero-based column index of the array.
    * \param y is the zero-based row index of the array.
    *
    * \return a reference to the element at position (x,y)
    */
    const T & operator () (int x, int y) const;

    /*! Constructor with array size.
     *
     * No default constructor is provided as it makes no sense. 
     *
     * \param w is the width (columns) of the array
     * \param h is the height (rows) of the array
     */
    Array(unsigned int w, unsigned int h);  

    /*! Copy constructor.
    *
    * No default constructor is provided as it makes no sense.
    *
    * \param source is the array to replicate.
    */
    Array(const Array<T> & source);                      

    /*! Copy assignment operator
    *
    * \param source is the array to replicate.
    */
    Array & operator = (const Array<T> & source); 

    /*! Equality operator.
     *
     *  \param right is the array to compare the current object to.
     *
     *  \return true if the current array and the source have the same dimensions AND 
     *  one by one their elements of type T are the same. 
     */
    bool operator == (const Array<T> & right) const;    

    /*! Changes the internal array data storage size.
    *
    * If the one or both of the given dimensions are smaller, the array should be clipped
    * by discarding the remaining elements in the rows and/or columns outside the margins.
    * If the new dimensions are larger, pad the old elements with default values of type T.
    * If the array is not yet allocated (zero width and height), allocate the internal buffer and
    * set the array size according to the given dimensions.
    *
    * \param new_width is the user-provided width to resize the array to.
    * \param new_height is the user-provided height to resize the array to.
    */
    void resize(unsigned int new_width, unsigned int new_height);   

    /*! Virtual destructor.
     */
    virtual ~Array();                                    

    };

    //---------------------------------------------------------------------------------------------
    // Do NOT add the member function implementation here. Add all implementations in the Array.hpp 
    // file included below. The two files will be concatenated upon preprocessing.
    //---------------------------------------------------------------------------------------------


    } // namespace math

    #include "Array.hpp"

    #endif//------------------------------------------------------------

Just move it AFTER you declared math namespace and its content... — Adriano Repetti, Dec 14 '16 at 12:33
@AdrianoRepetti which i should move? it doesnt recognize the namespace for some reason! — madrugadas25845, Dec 14 '16 at 12:38
Because you're trying to use that namespace and its content BEFORE you declared it. Simply compiler _doesn't know_ about it (yet). — Adriano Repetti, Dec 14 '16 at 12:39
You shouldn't have an "Array.cpp" file. Read all the way to the end - "Add all implementations in the Array.hpp file included below." (And read [this](http://stackoverflow.com/questions/495021/why-can-templates-only-be-implemented-in-the-header-file).) — molbdnilo, Dec 14 '16 at 12:43
@molbdnilo yes that is the problem, so all the implementations should be in the Array.hpp — madrugadas25845, Dec 14 '16 at 12:53

score 0 · Answer 1 · answered Dec 14 '16 at 12:34

I suppose you have a problem of correct inclusion (see below) and the obvious fact that you have forgotten the parentheses in definition of getRawDataPtr(). I mean: you should write

      //                parentheses added -----> vv
      void * const math::Array<T>::getRawDataPtr ()
      {
      return buffer;
      }

Regarding the inclusion... your "array.h" include "array.hpp" but getRawDataPtr() is implemented in "array.cpp".

Have you confused "array.hpp" with "array.cpp" ?

What can I say is that the following code compile without errors

namespace math
 {
   template <typename T>
      class Array
       {
         protected:
            T * buffer;                     

            unsigned int width, height;            

         public:

            unsigned int getWidth() const { return width; }      
            unsigned int getHeight() const { return height; }    
            void * const getRawDataPtr();
            T & operator () (int x, int y);                      
            const T & operator () (int x, int y) const;
            Array(unsigned int w, unsigned int h);  
            Array(const Array<T> & source);                      
            Array & operator = (const Array<T> & source); 
            bool operator == (const Array<T> & right) const;    
            void resize(unsigned int new_width, unsigned int new_height);   
            virtual ~Array();                                    
       };
 } // namespace math

template<typename T>
void * const math::Array<T>::getRawDataPtr ()
 { return buffer; }

int main ()
 { }

@madrugadas25845 - I suppose in "array.hpp" or even in "array.h"; it's a template class so the full implementation should be visible when `Array` are used; `getRawDataPtr()` it's so short and simple that I think could be implemented in the body of `Array`, just as `getWidth()` and `getHeight()` — max66, Dec 14 '16 at 13:22

Template implementation & compiler

1 Answers1