Форум программистов, компьютерный форум CyberForum.ru

Generic inheritance. Templates - C++

Восстановить пароль Регистрация
 
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 02:46     Generic inheritance. Templates #1
Код компилируется.
Не могу разобраться то ли я как не правильно иерархию построил то ли компилятор глючит. Вообщем если я пишу в NumericArray.cpp

NumericArray<Type>:: то MS VC 2010 выдает мне список из методов и функций которые относятся к Array шаблону (базовому) и к NumericArray. Но когда я пишу тоже самое внутри реализации функции, то VC 2010 выдает мне список только шаблона NumericArray.
Кто ниб сталкивался с подобным глюком ?



Array_hpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
//                                                      
//                                                  (---.Array_hpp---)
//
#ifndef Array_HPP
#define Array_HPP
 
    #include <sstream>
    #include <iostream>
    #include <exception>
 
    template <class Type>   //Remove the "=double" default parameter.
    class Array
        {
    
            protected:              // Declaration of private data members 
              unsigned int m_size;
              Type*        m_data;          //m_data should be a pointer, since you want to allocate data to it
 
            public:                 // Public declaration of data members (in given example haven't ) and member functions 
              static int m_size_default;
                //----------- Declaration of Constructors -----------//
              Array();                                  // Default constructor
              Array(const unsigned int new_size);       // Constructor 
              Array(const Array<Type>& ObjArray);       // Copy constructor
              ~Array();                                 // Destructor
 
              //----------- Declaration of  Accessors member functions -----------//
              Type& GetElement(const unsigned int index) const;
              static int  DefaultSize() ;
              int Size() const;
 
              //----------- Declaration of Modificator(s) member functions -----------//
              void Swap(Array& ObjArray);  
              void SetElement(const Type& ObjType, const unsigned int index);
              static void DefaultSize( int newSize) ;
 
              //----------- Declaration of Overloaded Operator(s) -----------//
              Array<Type>& operator =   (const Array& ObjArray);                //Const correctness here.
              const Type& operator  []  (unsigned int index) const;
              Type& operator        []  (unsigned int index);           
        };
///*
    #ifndef Array_cpp // Must be the same name as in source file #define
 
        #include "Array.cpp"
 
    #endif //#ifndef Array_cpp is CLOSED
//*/
 
//  #include "Array.inl"
#endif //  #ifndef Array_HPP is CLOSED


NUMERICARRAY_HPP
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#ifndef NUMERICARRAY_HPP
#define NUMERICARRAY_HPP
 
#include "Array.hpp"
 
    template <class Type> 
    class NumericArray: public Array<Type>
 
 
 
        {
            public: 
                    //----------- Declaration of Constructors -----------//
                NumericArray();
                NumericArray(int new_size);
                ~NumericArray(); 
 
               //----------- Declaration of Calculator(s) (additional functionality) member(s) function -----------//
 
               NumericArray<Type> DotProduct (const NumericArray<Type>& ObjNumericArray) const;
               
               //----------- Declaration of Overloaded Operator(s) -----------//
                NumericArray<Type>& operator = (const NumericArray<Type>& ObjNumericArray); 
                NumericArray<Type>  operator * (double factor) const;    
 
                NumericArray<Type>  operator +  (const NumericArray<Type>& ObjNumericArray) const; 
                // Throw an exception if the two arrays have not the same size.
        };
 
        ///*
    #ifndef NumericArray_cpp // Must be the same name as in source file #define
 
        #include "NumericArray.cpp"
 
    #endif //#ifndef NumericArray_cpp is CLOSED
//*/
 
#endif //NumericArray_h


Point_hpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
//                                                      
//                                                  (---.Point_hpp---)
//  
#ifndef Point_HPP // anti multiply including gates
#define Point_HPP
 
// Lib(s)
    #include <string>
    #include <iostream>
    #include <sstream>
    #include <cmath>
 
 
 
 
    class Point 
        {   
            private:        // Declaration of private data members 
            double x;       // X coordinate
            double y;       // Y coordinate
 
            public: // Public declaration of data members (in given example haven't ) and member functions 
 
 
                //----------- Declaration of Constructors -----------//
            Point();                                                // Default constructor
            Point(const double newX ,const double newY) ;           // Constructor 
            explicit Point(const double value );                    // Second Constructor 
            Point (const Point& ObjectOfClassPoint);                // Copy constructor
            ~Point();                                               // Destructor
 
 
            //----------- Declaration of  Accessors member functions -----------//
            std::string ToString() const;    
            double X() const;                   
            double Y() const;   
            ///*virtual*/ void Draw() const { std::cout << "This's  Point from Draw()\n"; }
 
 
            //----------- Declaration and  of and Implementaion of setters member functions -----------//
            void X(const double newX) {x = newX;};  // The x-coordinate
            void Y(const double newY) {y = newY;};  // The y-coordinate
 
 
            //----------- Declaration of Calculators (additional functionality) member functions -----------//
            double Distance() const;
            double Distance(  const Point  & ObjPoint ) const;
 
 
            //----------- Declaration of Operators Overloading the class's members -----------//
            Point  operator -  () const;                                    // Negate the coordinates.
            Point  operator *  (double factor) const;                       // Scale the coordinates.
            Point  operator +  (const Point& ObjPoint) const;               // Add coordinates.
            bool   operator == (const Point& ObjPoint) const;               // Equally compare operator.
            Point& operator =  (const Point& ObjPoint);                 // Assignment operator.
            Point& operator *= (double factor );                        // Scale the coordinates & assign.
            Point& operator += (const Point& ObjPoint);
            Point& operator -= (const Point& ObjPoint);
 
 
            //----------- Declaration of Global Ostream << Operator  -----------//
            friend std::ostream& operator << (std::ostream& out,const Point & ObjPoint); 
    
        };
 
    //----------- Implementaion (inline) of getters member functions -----------//
    // Given functions should be const because we not willing modify contained variables when we call those fucntions in any case
    inline  double Point::X() const {return x;};                    
    inline  double Point::Y() const {return y;};    
 
 
#endif // Point_HPP


Array_CPP
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
//                                                      
//                                                  (---.Array_CPP---)
//  
    #ifndef Array_CPP
    #define Array_CPP
 
        #include "Array.hpp"
    
    template <class Type>
int Array<Type>::m_size_default = 10;
 
        //----------- Implementation of Constructors -----------//
        template <class Type>
        Array<Type>::Array() : m_size(10), m_data(0)
            { 
 
            }
 
        template <class Type>
        Array<Type>::Array(unsigned int new_size) 
            : m_size(new_size), m_data(new Type[new_size])
            { 
 
            }
 
        template <class Type>
        Array<Type>::Array(const Array& ObjArray) : m_data(0), m_size(0)
            {
                
              if(!ObjArray.m_data) {return;}
 
              Array tmp;                // Copy construct into another temporary array, 
                                        // this way, if something throws, tmp will clean itself up.
 
              //Create the array
              tmp.m_data = new Type[ObjArray.m_size];
              tmp.m_size = ObjArray.m_size;
 
              //Copy the array elements
              for(unsigned int i = 0; i < tmp.m_size; ++i)
                {tmp.m_data[i] = ObjArray.m_data[i];}
 
              //All done! swap into this!
              this->Swap(tmp);
            }
 
 
        template <class Type>
        Array<Type>::~Array()
            {
              //Technically, the if is not necessary
              if(m_data)
              {
                delete[] m_data;
                m_data = 0;
              }
 
              //Not necessary either, but just to be clean
              m_size = 0;
            }
 
        //----------- Implementation of Accessor(s) member functions -----------//
 
        template <class Type> 
        Type& Array<Type>::GetElement(const unsigned int index) const
            {
                std::cout 
                << "GetElement -> " ;
    
                    if (index >= m_size || index < 0)
                        { 
                            throw std::out_of_range 
                                ("Out of range error in void Array<Type>::GetElement");
                        } 
 
                return m_data[index];
            }
 
        template <typename Type>
        int Array<Type>::DefaultSize() 
            { 
                return m_size_default;
            }
 
        template<class Type>
        int Array<Type>::Size() const
        {
            return this->m_size; 
        }
 
        
        //----------- Implementaion of Modificator(s) member(s) function -----------//
 
        template <class Type>
        void Array<Type>::Swap(Array& ObjArray)
            {
                //std::swap()  - try to implement std swap function 
              Type* data = m_data;
       unsigned int size = m_size;
              m_data     = ObjArray.m_data;
              m_size     = ObjArray.m_size;
         ObjArray.m_data = data;
         ObjArray.m_size = size;
            }
 
        template <class Type> 
        void Array<Type>::SetElement(const Type& ObjType,unsigned int index)
            {
 
                    if (index >= m_size || index < 0 )
                        {
                            throw std:: out_of_range ("out of range error in void Array<Type>::SetElement");
                        }
                    m_data[index] = ObjType;
            //  std::cout << "Set Element <- " << ObjType  << std::endl;
            }
 
        template <typename Type>
        void Array<Type>::DefaultSize( int newSize) 
            { 
                m_size_default = newSize; 
            }
 
        //----------- Implementation of Operators Overloading the class's member -----------//
        
        template <class Type>
        Array<Type>& Array<Type>::operator = (const Array& ObjArray)
            {
              //Check self assign:
              if(this == &ObjArray) {return *this;}
 
              Array<Type> copy(ObjArray);   //Create a copy of ObjArray; If this fails, then *this will not be changed, and nothing will leak
 
                                            //Succeeded creating copy. Now we can put it inside this
              this->Swap(copy);             //And then swap the copy into this!
 
              return *this;
            }
 
        template <class Type> 
        Type& Array<Type>::operator [] (unsigned int index) 
            {
            //  cout << "Array [] operator" << endl;
 
                if (index >= this->m_size)
                    {
                        cout << "i am hreeeee" << endl;
                        return this->m_data[0];
                    }
                return m_data[index];
            }
 
        template <class Type> 
        const Type& Array<Type>::operator [] (unsigned int index) const
        {   
            if (index > this-> m_size)
                    {
                        std::cout 
                            << "OUT OF BOUND ";
                        return this->m_data[0];
                    }
            return m_data[index];
        }
 
 
 
    #endif //Array_CPP


NumericArray_cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//                                                      
//                                                  (---.NumericArray_cpp---)
//  
 
    #ifndef NumericArray_CPP
    #define NumericArray_CPP
 
 
#include "NumericArray.hpp"
 
 
        template <class Type>
    NumericArray<Type>::NumericArray(): m_size(10), m_data(0) // default filling of array is zeros!
    {
    }
 
    template <class Type>
    NumericArray<Type>::NumericArray(int new_size) : Array<Type>( new_size)//: m_size(new_size), m_data(new Type[new_size])
    { 
    }
 
    template <class Type>
    NumericArray<Type>& NumericArray<Type>::operator=(const NumericArray<Type>& ar) 
    {
         Array<Type>::operator = (ar);  // call base class assignment operator
         return *this;
    }
 
    template <class Type>
    NumericArray<Type>::~NumericArray()
    {
      //Technically, the if is not necessary
      if(m_data)
      {
        delete[] m_data;
        m_data = 0;
      }
      //Not necessary either, but just to be clean
      m_size = 0;
    }
 
    template<class Type>
    NumericArray<Type> NumericArray<Type>::operator *(double factor) const
    {
        
       NumericArray<Type> output(Array<Type>::Size());
       for(int i=0; i<Size(); i++)
       {
          output[i] = (*this)[i] * factor;
          //return output;
       }
       return output;
    }
#endif //NumericArray_cpp


Point_cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
//                                                      
//                                                  (---.Point_cpp---)
//  
    #include "Point.hpp"
 
 int number_of_point_constructor_calls          = 1 ;   
 int number_of_point_destructor_calls           = 1 ;  
 int number_of_point_assignment_operator_calls  = 1 ; 
 
 
                //----------- Implementation of Constructors -----------//
    Point::Point() : x(0) , y(0)            // Default constructor (implemented using colon syntax )                                    
            { 
            //  std::cout << "hi my default constructor\n\n\t";
            }                           
 
 
    Point::Point(const double newX ,const double newY) : x(newX)  , y(newY)     // Constructor 
            { 
        //      std::cout << " My Point constructor was called " << number_of_point_constructor_calls++ << " times " << "\n"; 
            }                   
 
    Point::Point(const double value ) : x(value)                // Second Constructor 
            { 
            //std::cout << "hi my constructor\n\n\t"; 
            }   
    Point::~Point()                                             // Destructor
            {
            //  std::cout << " My Point destructor was called " << number_of_point_destructor_calls++ << " times " << "\n"; 
            }                                    
 
    Point::Point (const Point& ObjectOfClassPoint)              // Copy constructor
            {
                //std::cout << "this is COPY constructor\n\n\t ";
                x = ObjectOfClassPoint.x;
                y = ObjectOfClassPoint.y;
            }
        
 
                //----------- Implementation of Accessor(s) member functions -----------//
    std::string Point::ToString() const
            {
            //  std::string s=Shape::ToString();                                
                std::ostringstream os;                          // std::stringstream object
                os << " Point (" << x << ", " << y << ") " ;    // customization of output and calling base class functuanality 
                return os.str();                                // str() function retrieve the string from the string buffer
            }
 
 
                //----------- Implementation of Calculators (additional functionality) member functions -----------//
    double  Point::Distance() const
 
            {
                return std::sqrt(pow(x,2) + pow(y,2));
            }
 
 
    double  Point::Distance(const Point   &ObjPt ) const
    
            {
                return std::sqrt(pow((x-ObjPt.x),2) + pow(y - ObjPt.y,2)); 
            }
 
 
            //----------- Implementation of Operators Overloading the class's member -----------//
    Point Point::operator  -  () const                                  // Negate the coordinates.          
        {
            return Point(-x,-y);
        }
 
    Point Point::operator  *  (double factor) const                     // Scale the coordinates.
        {
            return Point(x * factor, y * factor);
        }
 
    Point Point::operator  +  (const Point& ObjPoint) const             // Add coordinates.
        { 
            return Point(x + ObjPoint.x, y + ObjPoint.y);
        }
 
    bool Point::operator   == (const Point& ObjPoint) const             // Equally compare operator.    
        {
            return (x==ObjPoint.x)&(y==ObjPoint.y);
        }
 
    Point& Point::operator =  (const Point& ObjPoint)                           // Assignment operator.             
                {       
            //      std::cout << " My Point assignment operator was called " << number_of_point_assignment_operator_calls++ << " times " << "\n"; 
                    x=ObjPoint.x, y=ObjPoint.y;
                    return *this;                                               // The meaning of *this explained in this example (implementation) see comment out  
                }
 
    Point& Point::operator *= (double factor)                                   // Scale the coordinates & assign.      
        {
            x *= factor; 
            y *= factor;
 
            return *this ; 
        }
    
 
    Point& Point::operator += (const Point& ObjPoint)  
        {
                x += ObjPoint.x;
                y += ObjPoint.y;
 
                return *this;
        }
 
    Point& Point::operator -= (const Point& ObjPoint)
        {
                x -= ObjPoint.x;
                y -= ObjPoint.y;
 
                return *this;
        }
 
 
    //----------- Implementation of GLOBAL Ostream << Operator  -----------//
    std::ostream& operator << (std::ostream& out,const Point & ObjPoint)
            {
                return out << "[" << ObjPoint.x << "," << ObjPoint.y << "]" ; 
                
            }


main_cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//                                                      
//                                                  (---.main_cpp---)
//
        #include "Point.hpp"
        #include "Array.cpp"
        #include <exception>
        #include "NumericArray.hpp"
        #include <iostream>
 
        using namespace std;
int main()
{
              //Create two Point arrays and test the operators
    NumericArray<Point> pArray1(5);
    NumericArray<Point> pArray2(5);
    
    //Array<Point> PointArray (5);
    //initialize
    //for (int i=0; i!=PointArray.Size(); i++ ) PointArray[i] = Point (2*i,2*i); 
    for(int i=0; i<pArray1.Size(); i++) pArray1[i] = Point(i, i);
    for(int i=0; i<pArray2.Size(); i++) pArray2[i] = Point(7*i, 4*i);
 
    //Numeric Array's operations not working for Point objects
 
 
    
     Array<Point> PointArray = pArray1 * 34 ;
     
    
    for(int i=0; i<PointArray.Size(); i++)
    {
        cout << PointArray[i] << endl;
    }
 
    return 0;
}
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
03.08.2012, 02:46     Generic inheritance. Templates
Посмотрите здесь:

Templates. (concrete inheritance). question to destructor implementation C++
C++ Copy Constructor Question .Generic inheritance. Templates
Variadic Templates C++
templates, STL C++
C++ Неоднозначность и multiple inheritance
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
03.08.2012, 09:13     Generic inheritance. Templates #2
Проект компилируется? У вас, вроде-бы, были не шаблонные классы? Насколько я занаю, шаблоны и их реализации должны быть в одном файле.
ForEveR
Модератор
Эксперт C++
 Аватар для ForEveR
7927 / 4709 / 318
Регистрация: 24.06.2010
Сообщений: 10,524
Завершенные тесты: 3
03.08.2012, 09:22     Generic inheritance. Templates #3
alsav22, Да нет. Инклуд .cpp в конце - вполне себе решение, правда лучше файлу дать другое расширение
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 09:57  [ТС]     Generic inheritance. Templates #4
Цитата Сообщение от alsav22 Посмотреть сообщение
Проект компилируется? У вас, вроде-бы, были не шаблонные классы? Насколько я занаю, шаблоны и их реализации должны быть в одном файле.
Да компилируется, а теперь шаблонные )
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 10:01  [ТС]     Generic inheritance. Templates #5
Цитата Сообщение от ForEveR Посмотреть сообщение
alsav22, Да нет. Инклуд .cpp в конце - вполне себе решение, правда лучше файлу дать другое расширение
Так что на счет наследования... ребят, ай нид хелп ! у меня еще диаграмка есть для наглядности
Миниатюры
Generic inheritance. Templates  
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
03.08.2012, 10:09     Generic inheritance. Templates #6
Цитата Сообщение от Leeto Посмотреть сообщение
template <class Type>
NumericArray<Type>::NumericArray(): m_size(10), m_data(0) // default filling of array is zeros!
{
}
Таких полей нет в NumericArray. Если же тут имеется ввиду инициализация полей базового класса, то так не пишется. Тут можно ничего не писать. Автоматически будет вызван конструктор базового класса по умолчанию.

Добавлено через 57 секунд
Цитата Сообщение от Leeto Посмотреть сообщение
Да компилируется
Не понимаю, как это может быть. У меня mingv кучу ошибок выдаёт.
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 10:13  [ТС]     Generic inheritance. Templates #7
Цитата Сообщение от Leeto Посмотреть сообщение
Так что на счет наследования... ребят, ай нид хелп ! у меня еще диаграмка есть для наглядности
Вот еще принскрин на котором видно что когда я создаю объект шаблона NumericArray то он беру его имя ставлю точку и ms vc предлагает мне все что он знает об этом шаблоне и он его базовом классе. Значит ли это что все нормально наследуется ??? и то что у меня действительно глюк когда я пытаюсь вызвать методы базового класса внутри метода деривативного или все таки это не глюк ???
Миниатюры
Generic inheritance. Templates  
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 10:14  [ТС]     Generic inheritance. Templates #8
Цитата Сообщение от alsav22 Посмотреть сообщение
Таких полей нет в NumericArray. Если же тут имеется ввиду инициализация полей базового класса, то так не пишется. Тут можно ничего не писать. Автоматически будет вызван конструктор базового класса по умолчанию.

Добавлено через 2 минуты
Это я своё сообщение удалил.

Добавлено через 57 секунд
Не понимаю, как это может быть. У меня mingv кучу ошибок выдаёт.
Да мне тоже кажется что не должно компилироваться... но у меня компилируется
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
03.08.2012, 10:15     Generic inheritance. Templates #9
Array_CPP 149 строка:
C++
1
cout << "i am hreeeee" << endl;
Должно быть :
C++
1
std::cout << "i am hreeeee" << std::endl;
И это компилятор пропускает?
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 10:24  [ТС]     Generic inheritance. Templates #10
Цитата Сообщение от alsav22 Посмотреть сообщение
Таких полей нет в NumericArray. Если же тут имеется ввиду инициализация полей базового класса, то так не пишется. Тут можно ничего не писать. Автоматически будет вызван конструктор базового класса по умолчанию.

Добавлено через 2 минуты
Это я своё сообщение удалил.

Добавлено через 57 секунд
Не понимаю, как это может быть. У меня mingv кучу ошибок выдаёт.
Короче на на какой то не понятной магии держалась моя компиляция сейчас выдает ран тайм ошибку

C++
1
2
3
4
5
6
7
8
9
10
11
        template <class Type>
    NumericArray<Type>::NumericArray() //: m_size(10), m_data(0) // default filling of array is zeros!
    {
    }
    
    template <class Type>
    NumericArray<Type>::NumericArray(int new_size)  //: m_size(new_size), m_data(new Type[new_size])
    { 
 
            
    }
Конструкторы сделал пустыми
Миниатюры
Generic inheritance. Templates  
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
03.08.2012, 11:37     Generic inheritance. Templates #11
Это может не из-за кода. С небольшими исправлениями, у меня Студия тоже компилирует. Это
C++
1
 Array<Type>::Array(const Array& ObjArray) : m_data(0), m_size(0)
работает, так как m_data и m_size у вас в protected, это я просмотрел, но почему-то mingv это не нравилось.

Добавлено через 1 час 5 минут
Добился, чтобы mingv не ругался на ваш код. Этот компилятор построже, конечно, чем Студия. В производном классе он только так пропускает обращение к protected-членам базового:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template <class Type>
NumericArray<Type>::NumericArray() : Array<Type>::m_size(10), Array<Type>::m_data(0) // default filling of array is zeros!
{
    
}
..........................................................
template <class Type>
NumericArray<Type>::~NumericArray()
{
  //Technically, the if is not necessary
      if(Array<Type>::m_data)
      {
            delete[] Array<Type>::m_data;
           Array< Type>::m_data = 0;
      }
  //Not necessary either, but just to be clean
      Array<Type>::m_size = 0;
}
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 14:43  [ТС]     Generic inheritance. Templates #12
Цитата Сообщение от alsav22 Посмотреть сообщение
Это может не из-за кода. С небольшими исправлениями, у меня Студия тоже компилирует. Это
C++
1
 Array<Type>::Array(const Array& ObjArray) : m_data(0), m_size(0)
работает, так как m_data и m_size у вас в protected, это я просмотрел, но почему-то mingv это не нравилось.

Добавлено через 1 час 5 минут
Добился, чтобы mingv не ругался на ваш код. Этот компилятор построже, конечно, чем Студия. В производном классе он только так пропускает обращение к protected-членам базового:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template <class Type>
NumericArray<Type>::NumericArray() : Array<Type>::m_size(10), Array<Type>::m_data(0) // default filling of array is zeros!
{
    
}
..........................................................
template <class Type>
NumericArray<Type>::~NumericArray()
{
  //Technically, the if is not necessary
      if(Array<Type>::m_data)
      {
            delete[] Array<Type>::m_data;
           Array< Type>::m_data = 0;
      }
  //Not necessary either, but just to be clean
      Array<Type>::m_size = 0;
}

Короче я вот так вот сделал вроде все ок...

code update

Array_hpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
//                                                      
//                                                  (---.Array_hpp---)
//
#ifndef Array_HPP
#define Array_HPP
 
    #include <sstream>
    #include <iostream>
    #include <exception>
 
    template <class Type>   //Remove the "=double" default parameter.
    class Array
        {
    
            protected:              // Declaration of private data members 
              unsigned int m_size;
              Type*        m_data;          //m_data should be a pointer, since you want to allocate data to it
 
            public:                 // Public declaration of data members (in given example haven't ) and member functions 
              static int m_size_default;
                //----------- Declaration of Constructors -----------//
              Array();                                  // Default constructor
              Array(const unsigned int new_size);       // Constructor 
              Array(const Array<Type>& ObjArray);       // Copy constructor
              ~Array();                                 // Destructor
 
              //----------- Declaration of  Accessors member functions -----------//
              Type& GetElement(const unsigned int index) const;
              static int  DefaultSize() ;
              int Size() const;
 
              //----------- Declaration of Modificator(s) member functions -----------//
              void Swap(Array& ObjArray);  
              void SetElement(const Type& ObjType, const unsigned int index);
              static void DefaultSize( int newSize) ;
 
              //----------- Declaration of Overloaded Operator(s) -----------//
              Array<Type>& operator =   (const Array& ObjArray);                //Const correctness here.
              const Type& operator  []  (unsigned int index) const;
              Type& operator        []  (unsigned int index);           
        };
///*
    #ifndef Array_cpp // Must be the same name as in source file #define
 
        #include "Array.cpp"
 
    #endif //#ifndef Array_cpp is CLOSED
//*/
 
//  #include "Array.inl"
#endif //  #ifndef Array_HPP is CLOSED


NUMERICARRAY_HPP
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#ifndef NUMERICARRAY_HPP
#define NUMERICARRAY_HPP
 
#include "Array.hpp"
 
    template <class Type> 
    class NumericArray: public Array<Type>
 
 
 
        {
            public: 
                    //----------- Declaration of Constructors -----------//
                NumericArray();
                NumericArray(int new_size);
                ~NumericArray(); 
 
               //----------- Declaration of Calculator(s) (additional functionality) member(s) function -----------//
 
            //   Type& DotProduct ( NumericArray<Type>& ObjNumericArray) const;
               
               //----------- Declaration of Overloaded Operator(s) -----------//
                NumericArray<Type>& operator = (const NumericArray<Type>& ObjNumericArray); 
                NumericArray<Type>  operator * ( double factor) const;    
 
                 NumericArray<Type>  operator +  (const NumericArray<Type>& ObjNumericArray) const; 
                // Throw an exception if the two arrays have not the same size.
        };
 
    
    #ifndef NumericArray_cpp 
 
        #include "NumericArray.cpp"
 
    #endif //#ifndef NumericArray_cpp is CLOSED
 
 
#endif //NumericArray_h


Point_hpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
//                                                      
//                                                  (---.Point_hpp---)
//  
#ifndef Point_HPP // anti multiply including gates
#define Point_HPP
 
// Lib(s)
    #include <string>
    #include <iostream>
    #include <sstream>
    #include <cmath>
 
 
 
 
    class Point 
        {   
            private:        // Declaration of private data members 
            double x;       // X coordinate
            double y;       // Y coordinate
 
            public: // Public declaration of data members (in given example haven't ) and member functions 
 
 
                //----------- Declaration of Constructors -----------//
            Point();                                                // Default constructor
            Point(const double newX ,const double newY) ;           // Constructor 
            explicit Point(const double value );                    // Second Constructor 
            Point (const Point& ObjectOfClassPoint);                // Copy constructor
            ~Point();                                               // Destructor
 
 
            //----------- Declaration of  Accessors member functions -----------//
            std::string ToString() const;    
            double X() const;                   
            double Y() const;   
            ///*virtual*/ void Draw() const { std::cout << "This's  Point from Draw()\n"; }
 
 
            //----------- Declaration and  of and Implementaion of setters member functions -----------//
            void X(const double newX) {x = newX;};  // The x-coordinate
            void Y(const double newY) {y = newY;};  // The y-coordinate
 
 
            //----------- Declaration of Calculators (additional functionality) member functions -----------//
            double Distance() const;
            double Distance(  const Point  & ObjPoint ) const;
 
 
            //----------- Declaration of Operators Overloading the class's members -----------//
            Point  operator -  () const;                                    // Negate the coordinates.
            Point  operator *  (double factor) const;                       // Scale the coordinates.
            Point  operator +  (const Point& ObjPoint) const;               // Add coordinates.
            bool   operator == (const Point& ObjPoint) const;               // Equally compare operator.
            Point& operator =  (const Point& ObjPoint);                 // Assignment operator.
            Point& operator *= (double factor );                        // Scale the coordinates & assign.
            Point& operator += (const Point& ObjPoint);
            Point& operator -= (const Point& ObjPoint);
 
 
            //----------- Declaration of Global Ostream << Operator  -----------//
            friend std::ostream& operator << (std::ostream& out,const Point & ObjPoint); 
    
        };
 
    //----------- Implementaion (inline) of getters member functions -----------//
    // Given functions should be const because we not willing modify contained variables when we call those fucntions in any case
    inline  double Point::X() const {return x;};                    
    inline  double Point::Y() const {return y;};    
 
 
#endif // Point_HPP


Array_CPP
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
//                                                      
//                                                  (---.Array_CPP---)
//  
    #ifndef Array_CPP
    #define Array_CPP
 
        #include "Array.hpp"
    
    template <class Type>
int Array<Type>::m_size_default = 10;
 
        //----------- Implementation of Constructors -----------//
        template <class Type>
        Array<Type>::Array() : m_size(10), m_data(0)
            { 
 
            }
 
        template <class Type>
        Array<Type>::Array(unsigned int new_size) 
            : m_size(new_size), m_data(new Type[new_size])
            { 
 
            }
 
        template <class Type>
        Array<Type>::Array(const Array& ObjArray) : m_data(0), m_size(0)
            {
                
              if(!ObjArray.m_data) {return;}
 
              Array tmp;                // Copy construct into another temporary array, 
                                        // this way, if something throws, tmp will clean itself up.
 
              //Create the array
              tmp.m_data = new Type[ObjArray.m_size];
              tmp.m_size = ObjArray.m_size;
 
              //Copy the array elements
              for(unsigned int i = 0; i < tmp.m_size; ++i)
                {tmp.m_data[i] = ObjArray.m_data[i];}
 
              //All done! swap into this!
              this->Swap(tmp);
            }
 
 
        template <class Type>
        Array<Type>::~Array()
            {
              //Technically, the if is not necessary
              if(m_data)
              {
                delete[] m_data;
                m_data = 0;
              }
 
              //Not necessary either, but just to be clean
              m_size = 0;
            }
 
        //----------- Implementation of Accessor(s) member functions -----------//
 
        template <class Type> 
        Type& Array<Type>::GetElement(const unsigned int index) const
            {
                std::cout 
                << "GetElement -> " ;
    
                    if (index >= m_size || index < 0)
                        { 
                            throw std::out_of_range 
                                ("Out of range error in void Array<Type>::GetElement");
                        } 
 
                return m_data[index];
            }
 
        template <typename Type>
        int Array<Type>::DefaultSize() 
            { 
                return m_size_default;
            }
 
        template<class Type>
        int Array<Type>::Size() const
        {
            return this->m_size; 
        }
 
        
        //----------- Implementaion of Modificator(s) member(s) function -----------//
 
        template <class Type>
        void Array<Type>::Swap(Array& ObjArray)
            {
                //std::swap()  - try to implement std swap function 
              Type* data = m_data;
       unsigned int size = m_size;
              m_data     = ObjArray.m_data;
              m_size     = ObjArray.m_size;
         ObjArray.m_data = data;
         ObjArray.m_size = size;
            }
 
        template <class Type> 
        void Array<Type>::SetElement(const Type& ObjType,unsigned int index)
            {
 
                    if (index >= m_size || index < 0 )
                        {
                            throw std:: out_of_range ("out of range error in void Array<Type>::SetElement");
                        }
                    m_data[index] = ObjType;
            //  std::cout << "Set Element <- " << ObjType  << std::endl;
            }
 
        template <typename Type>
        void Array<Type>::DefaultSize( int newSize) 
            { 
                m_size_default = newSize; 
            }
 
        //----------- Implementation of Operators Overloading the class's member -----------//
        
        template <class Type>
        Array<Type>& Array<Type>::operator = (const Array& ObjArray)
            {
              //Check self assign:
              if(this == &ObjArray) {return *this;}
 
              Array<Type> copy(ObjArray);   //Create a copy of ObjArray; If this fails, then *this will not be changed, and nothing will leak
 
                                            //Succeeded creating copy. Now we can put it inside this
              this->Swap(copy);             //And then swap the copy into this!
 
              return *this;
            }
 
        template <class Type> 
        Type& Array<Type>::operator [] (unsigned int index) 
            {
            //  std::cout << "Array [] operator" << std::endl;
 
                if (index >= this->m_size)
                    {
                        std::cout << "i am hreeeee" << std::endl;
                        return this->m_data[0];
                    }
                return m_data[index];
            }
 
        template <class Type> 
        const Type& Array<Type>::operator [] (unsigned int index) const
        {   
            if (index > this-> m_size)
                    {
                        std::cout 
                            << "OUT OF BOUND ";
                        return this->m_data[0];
                    }
            return m_data[index];
        }
 
 
 
    #endif //Array_CPP


NumericArray_cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
//                                                      
//                                                  (---.NumericArray_cpp---)
//  
 
    #ifndef NumericArray_CPP
    #define NumericArray_CPP
 
 
#include "NumericArray.hpp"
 
 
//template <class Type>
//Array<Type>::Array(); 
 
 
 
    template <class Type>
    NumericArray<Type>::NumericArray():Array() //: m_size(10), m_data(0) // default filling of array is zeros!
        {
                
        }
    
 
 
    template <class Type>
    NumericArray<Type>::NumericArray( int new_size): Array( new_size) //:Array() //: m_size(new_size), m_data(new Type[new_size])
    {
            
    }
 
            
            
        
 
    template <class Type>
    NumericArray<Type>& NumericArray<Type>::operator = (const NumericArray<Type>& ar) 
    {
         Array<Type>::operator = (ar);  // call base class assignment operator
         return *this;
    }
 
    template <class Type>
    NumericArray<Type>::~NumericArray()
    {
      //Technically, the if is not necessary
      if(m_data)
      {
        delete[] m_data;
        m_data = 0;
      }
      //Not necessary either, but just to be clean
      m_size = 0;
    }
 
    
 
    template<class Type>
    NumericArray<Type> NumericArray<Type>::operator *( double factor) const
    {
        
       NumericArray<Type> output(Array<Type>::Size());
       for(int i=0; i<Size(); i++)
       {
 
          output[i] = (*this)[i] * factor;
          //return output;
       }
       return output;
    }
        template<class Type>
     NumericArray<Type> NumericArray<Type>::operator +  (const NumericArray<Type>& ObjNumericArray) const
     {
        
       NumericArray<Type> output(Array<Type>::Size());
       for(int i=0; i<Size(); i++)
       {
 
          output[i] = (*this)[i] + ObjNumericArray[i];
          //return output;
       }
       return output;
     
     }
/*
     template<class Type>
     Type& NumericArray<Type>::DotProduct ( NumericArray<Type>& ObjNumericArray) const
     {
        
      Type Sum;
       for(int i=0; i<Size(); i++)
       {
          Sum = Sum +  (*this)[i] * ObjNumericArray[i];
          //return output;
       }
 
       return Sum;
     
     }
     */
 
#endif //NumericArray_cpp


Point_cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
//                                                      
//                                                  (---.Point_cpp---)
//  
    #include "Point.hpp"
 
 int number_of_point_constructor_calls          = 1 ;   
 int number_of_point_destructor_calls           = 1 ;  
 int number_of_point_assignment_operator_calls  = 1 ; 
 
 
                //----------- Implementation of Constructors -----------//
    Point::Point() : x(0) , y(0)            // Default constructor (implemented using colon syntax )                                    
            { 
            //  std::cout << "hi my default constructor\n\n\t";
            }                           
 
 
    Point::Point(const double newX ,const double newY) : x(newX)  , y(newY)     // Constructor 
            { 
        //      std::cout << " My Point constructor was called " << number_of_point_constructor_calls++ << " times " << "\n"; 
            }                   
 
    Point::Point(const double value ) : x(value)                // Second Constructor 
            { 
            //std::cout << "hi my constructor\n\n\t"; 
            }   
    Point::~Point()                                             // Destructor
            {
            //  std::cout << " My Point destructor was called " << number_of_point_destructor_calls++ << " times " << "\n"; 
            }                                    
 
    Point::Point (const Point& ObjectOfClassPoint)              // Copy constructor
            {
                //std::cout << "this is COPY constructor\n\n\t ";
                x = ObjectOfClassPoint.x;
                y = ObjectOfClassPoint.y;
            }
        
 
                //----------- Implementation of Accessor(s) member functions -----------//
    std::string Point::ToString() const
            {
            //  std::string s=Shape::ToString();                                
                std::ostringstream os;                          // std::stringstream object
                os << " Point (" << x << ", " << y << ") " ;    // customization of output and calling base class functuanality 
                return os.str();                                // str() function retrieve the string from the string buffer
            }
 
 
                //----------- Implementation of Calculators (additional functionality) member functions -----------//
    double  Point::Distance() const
 
            {
                return std::sqrt(pow(x,2) + pow(y,2));
            }
 
 
    double  Point::Distance(const Point   &ObjPt ) const
    
            {
                return std::sqrt(pow((x-ObjPt.x),2) + pow(y - ObjPt.y,2)); 
            }
 
 
            //----------- Implementation of Operators Overloading the class's member -----------//
    Point Point::operator  -  () const                                  // Negate the coordinates.          
        {
            return Point(-x,-y);
        }
 
    Point Point::operator  *  (double factor) const                     // Scale the coordinates.
        {
            return Point(x * factor, y * factor);
        }
 
    Point Point::operator  +  (const Point& ObjPoint) const             // Add coordinates.
        { 
            return Point(x + ObjPoint.x, y + ObjPoint.y);
        }
 
    bool Point::operator   == (const Point& ObjPoint) const             // Equally compare operator.    
        {
            return (x==ObjPoint.x)&(y==ObjPoint.y);
        }
 
    Point& Point::operator =  (const Point& ObjPoint)                           // Assignment operator.             
                {       
            //      std::cout << " My Point assignment operator was called " << number_of_point_assignment_operator_calls++ << " times " << "\n"; 
                    x=ObjPoint.x, y=ObjPoint.y;
                    return *this;                                               // The meaning of *this explained in this example (implementation) see comment out  
                }
 
    Point& Point::operator *= (double factor)                                   // Scale the coordinates & assign.      
        {
            x *= factor; 
            y *= factor;
 
            return *this ; 
        }
    
 
    Point& Point::operator += (const Point& ObjPoint)  
        {
                x += ObjPoint.x;
                y += ObjPoint.y;
 
                return *this;
        }
 
    Point& Point::operator -= (const Point& ObjPoint)
        {
                x -= ObjPoint.x;
                y -= ObjPoint.y;
 
                return *this;
        }
 
 
    //----------- Implementation of GLOBAL Ostream << Operator  -----------//
    std::ostream& operator << (std::ostream& out,const Point & ObjPoint)
            {
                return out << "[" << ObjPoint.x << "," << ObjPoint.y << "]" ; 
                
            }


Теперь у меня стоит задача сделать Функцию DotProduct (формула см приложение )

с DotProduct я что то запутался подскажите как правильно сделать, пожалуйста, соответственно оператор * и оператор + для ДОтПродукт уже готовы.
Миниатюры
Generic inheritance. Templates  
ForEveR
Модератор
Эксперт C++
 Аватар для ForEveR
7927 / 4709 / 318
Регистрация: 24.06.2010
Сообщений: 10,524
Завершенные тесты: 3
03.08.2012, 14:53     Generic inheritance. Templates #13
http://cplusplus.com/reference/std/n...inner_product/
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 15:04  [ТС]     Generic inheritance. Templates #14
так я вроде так и делаю


in NumericArray.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 template<class Type>
     Type& NumericArray<Type>::DotProduct ( NumericArray<Type>& ObjNumericArray) const
     {
        
      Type Sum;
       for(int i=0; i<Size(); i++)
       {
          Sum = Sum +  (*this)[i] * ObjNumericArray[i];
          //return output;
       }
 
       return Sum;
     
     }
in main.cpp
C++
1
2
3
4
5
6
7
8
9
10
 std::cout << "\nTEST of DotProduct  \n"  << std::endl; 
 
     NumericArray<Point> ObjDot;
 
     PointArray.DotProduct(pArray2); 
 
     
 
    return 0;
}
1>------ Build started: Project: L6_4.2b_ex2_Numeric_Array, Configuration: Release Win32 ------
1> main.cpp
1>\NumericArray.cpp(92): error C2679: binary '*' : no operator found which takes a right-hand operand of type 'Point' (or there is no acceptable conversion)
1> Point.hpp(52): could be 'Point Point::operator *(double) const'
1> while trying to match the argument list '(const Point, Point)'
1> \NumericArray.cpp(87) : while compiling class template member function 'Point &NumericArray<Type>:otProduct(NumericArray<Type> &) const'
1> with
1> [
1> Type=Point
1> ]
1> main.cpp(14) : see reference to class template instantiation 'NumericArray<Type>' being compiled
1> with
1> [
1> Type=Point
1> ]
1>c:\all my\с++\lab_from_level_5\lab_from_level_5\l6_4.2b_ex2_numeric_array\NumericArray.cpp(96): warning C4172: returning address of local variable or temporary
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

он что то на const ругается причем в Point class очень бы не хотелось в этом классе что либо менять

NumericArray.cpp 92 line : Sum = Sum + (*this)[i] * ObjNumericArray[i];
Point.hpp 52 line : Point operator * (double factor) const; // Scale the coordinates.

NumericArray.cpp line 86 : Type& NumericArray<Type>:otProduct ( NumericArray<Type>& ObjNumericArray) const
NumericArray.cpp line 87 : {

Type Sum;

main.cpp line 14 : NumericArray<Point> pArray1(5);
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
03.08.2012, 15:08     Generic inheritance. Templates #15
В Array_CPP, в 28 строке поменяйте, на всякий случай, порядок инициализации m_data и m_size. Помнится, в прошлом вашем коде, с этим была некая проблемка.
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 17:12  [ТС]     Generic inheritance. Templates #16
Цитата Сообщение от alsav22 Посмотреть сообщение
В Array_CPP, в 28 строке поменяйте, на всякий случай, порядок инициализации m_data и m_size. Помнится, в прошлом вашем коде, с этим была некая проблемка.
решил попробовать с двумя аргументами

main
C++
1
2
3
4
5
6
7
8
9
10
std::cout << "\nTEST of DotProduct  \n"  << std::endl; 
 
     NumericArray<Point> ObjDot;
 
       ObjDot.DotProduct(pArray2, pArray2); 
 
     
 
    return 0;
}
NumericArray
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 template<class Type>
     Type& NumericArray<Type>::DotProduct (const NumericArray<Type>& ObjFirstNumericArray,
                                            const NumericArray<Type>& ObjSecondNumericArray ) 
     {
        
     // Type& Sum;
       for(int i=0; i<Size(); i++)
       {
          *this = *this + ( ObjFirstNumericArray[i] * ObjSecondNumericArray[i] );
          //return output;
       }
 
       return *this;
     
     }
Не могу понять что ему не нравиться

-- Build started: Project: L6_4.2b_ex2_Numeric_Array, Configuration: Release Win32 ------
1> main.cpp
1>\NumericArray.cpp(93): error C2679: binary '*' : no operator found which takes a right-hand operand of type 'const Point' (or there is no acceptable conversion)
1> Point.hpp(52): could be 'Point Point::operator *(double) const'
1> while trying to match the argument list '(const Point, const Point)'
1> NumericArray.cpp(88) : while compiling class template member function 'Point &NumericArray<Type>:otProduct(const NumericArray<Type> &,const NumericArray<Type> &)'
1> with
1> [
1> Type=Point
1> ]
1> main.cpp(14) : see reference to class template instantiation 'NumericArray<Type>' being compiled
1> with
1> [
1> Type=Point
1> ]
1>c:\\NumericArray.cpp(97): error C2440: 'return' : cannot convert from 'NumericArray<Type>' to 'Point &'
1> with
1> [
1> Type=Point
1> ]
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

Добавлено через 1 час 41 минуту
КОД компилируется.

Вопрос следующий. Функция DotProduct in NumericArray template

если делать ее void то все нормально если Type& то возвращает гов..окоординаты точки (см принскрин )

update code:

Array_hpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
//                                                      
//                                                  (---.Array_hpp---)
//
#ifndef Array_HPP
#define Array_HPP
 
    #include <sstream>
    #include <iostream>
    #include <exception>
 
    template <class Type>   //Remove the "=double" default parameter.
    class Array
        {
    
            protected:              // Declaration of private data members 
              unsigned int m_size;
              Type*        m_data;          //m_data should be a pointer, since you want to allocate data to it
 
            public:                 // Public declaration of data members (in given example haven't ) and member functions 
              static int m_size_default;
                //----------- Declaration of Constructors -----------//
              Array();                                  // Default constructor
              Array(const unsigned int new_size);       // Constructor 
              Array(const Array<Type>& ObjArray);       // Copy constructor
              ~Array();                                 // Destructor
 
              //----------- Declaration of  Accessors member functions -----------//
              Type& GetElement(const unsigned int index) const;
              static int  DefaultSize() ;
              int Size() const;
 
              //----------- Declaration of Modificator(s) member functions -----------//
              void Swap(Array& ObjArray);  
              void SetElement(const Type& ObjType, const unsigned int index);
              static void DefaultSize( int newSize) ;
 
              //----------- Declaration of Overloaded Operator(s) -----------//
              Array<Type>& operator =   (const Array& ObjArray);                //Const correctness here.
              const Type& operator  []  (unsigned int index) const;
              Type& operator        []  (unsigned int index);           
        };
///*
    #ifndef Array_cpp // Must be the same name as in source file #define
 
        #include "Array.cpp"
 
    #endif //#ifndef Array_cpp is CLOSED
//*/
 
//  #include "Array.inl"
#endif //  #ifndef Array_HPP is CLOSED


NumericArray_hpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
//                                                      
//                                                  (---.NumericArray_hpp---)
//
#ifndef NUMERICARRAY_HPP
#define NUMERICARRAY_HPP
 
#include "Array.hpp"
 
    template <class Type> 
    class NumericArray: public Array<Type>
 
 
 
        {
            public: 
                    //----------- Declaration of Constructors -----------//
                NumericArray();
                NumericArray(int new_size);
                ~NumericArray(); 
 
               //----------- Declaration of Calculator(s) (additional functionality) member(s) function -----------//
 
 
            //  Type& DotProduct (const NumericArray<Type> ObjFirstNumericArray ) ;
              void DotProduct ( NumericArray<Type> ObjFirstNumericArray ) ;
        
 
               //----------- Declaration of Overloaded Operator(s) -----------//
                NumericArray<Type>& operator = (const NumericArray<Type>& ObjNumericArray); 
                NumericArray<Type>  operator * ( double factor) const;    
 
                NumericArray<Type>  operator * ( const NumericArray<Type>& ObjNumericArray) const;   
 
                 NumericArray<Type>  operator +  (const NumericArray<Type>& ObjNumericArray) const; 
 
                // Throw an exception if the two arrays have not the same size.
        };
 
    
    #ifndef NumericArray_cpp 
 
        #include "NumericArray.cpp"
 
    #endif //#ifndef NumericArray_cpp is CLOSED
 
 
#endif //NumericArray_h


Point_hpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
//                                                      
//                                                  (---.Point_hpp---)
//  
#ifndef Point_HPP // anti multiply including gates
#define Point_HPP
 
// Lib(s)
    #include <string>
    #include <iostream>
    #include <sstream>
    #include <cmath>
 
 
 
 
    class Point 
        {   
            private:        // Declaration of private data members 
            double x;       // X coordinate
            double y;       // Y coordinate
 
            public: // Public declaration of data members (in given example haven't ) and member functions 
 
 
                //----------- Declaration of Constructors -----------//
            Point();                                                // Default constructor
            Point(const double newX ,const double newY) ;           // Constructor 
            explicit Point(const double value );                    // Second Constructor 
            Point (const Point& ObjectOfClassPoint);                // Copy constructor
            ~Point();                                               // Destructor
 
 
            //----------- Declaration of  Accessors member functions -----------//
            std::string ToString() const;    
            double X() const;                   
            double Y() const;   
            ///*virtual*/ void Draw() const { std::cout << "This's  Point from Draw()\n"; }
 
 
            //----------- Declaration and  of and Implementaion of setters member functions -----------//
            void X(const double newX) {x = newX;};  // The x-coordinate
            void Y(const double newY) {y = newY;};  // The y-coordinate
 
 
            //----------- Declaration of Calculators (additional functionality) member functions -----------//
            double Distance() const;
            double Distance(  const Point  & ObjPoint ) const;
 
 
            //----------- Declaration of Operators Overloading the class's members -----------//
            Point  operator -  () const;                                    // Negate the coordinates.
            Point  operator *  (double factor) const;                       // Scale the coordinates.
            Point  operator *  (const Point& ObjPoint) const;                       // Scale the objects .
            Point  operator +  (const Point& ObjPoint) const;               // Add coordinates.
            bool   operator == (const Point& ObjPoint) const;               // Equally compare operator.
            Point& operator =  (const Point& ObjPoint);                 // Assignment operator.
            Point& operator *= (double factor );                        // Scale the coordinates & assign.
            Point& operator += (const Point& ObjPoint);
            Point& operator -= (const Point& ObjPoint);
 
 
            //----------- Declaration of Global Ostream << Operator  -----------//
            friend std::ostream& operator << (std::ostream& out,const Point & ObjPoint); 
    
        };
 
    //----------- Implementaion (inline) of getters member functions -----------//
    // Given functions should be const because we not willing modify contained variables when we call those fucntions in any case
    inline  double Point::X() const {return x;};                    
    inline  double Point::Y() const {return y;};    
 
 
#endif // Point_HPP


Array_CPP
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
//                                                      
//                                                  (---.Array_CPP---)
//  
    #ifndef Array_CPP
    #define Array_CPP
 
        #include "Array.hpp"
    
    template <class Type>
int Array<Type>::m_size_default = 10;
 
        //----------- Implementation of Constructors -----------//
        template <class Type>
        Array<Type>::Array() : m_data(0), m_size(10)
            { 
 
            }
 
        template <class Type>
        Array<Type>::Array(unsigned int new_size) 
            :  m_data(new Type[new_size]), m_size(new_size)
            { 
 
            }
 
        template <class Type>
        Array<Type>::Array(const Array& ObjArray) : m_data(0), m_size(0)
            {
                
              if(!ObjArray.m_data) {return;}
 
              Array tmp;                // Copy construct into another temporary array, 
                                        // this way, if something throws, tmp will clean itself up.
 
              //Create the array
              tmp.m_data = new Type[ObjArray.m_size];
              tmp.m_size = ObjArray.m_size;
 
              //Copy the array elements
              for(unsigned int i = 0; i < tmp.m_size; ++i)
                {tmp.m_data[i] = ObjArray.m_data[i];}
 
              //All done! swap into this!
              this->Swap(tmp);
            }
 
 
        template <class Type>
        Array<Type>::~Array()
            {
              //Technically, the if is not necessary
              if(m_data)
              {
                delete[] m_data;
                m_data = 0;
              }
 
              //Not necessary either, but just to be clean
              m_size = 0;
            }
 
        //----------- Implementation of Accessor(s) member functions -----------//
 
        template <class Type> 
        Type& Array<Type>::GetElement(const unsigned int index) const
            {
                std::cout 
                << "GetElement -> " ;
    
                    if (index >= m_size || index < 0)
                        { 
                            throw std::out_of_range 
                                ("Out of range error in void Array<Type>::GetElement");
                        } 
 
                return m_data[index];
            }
 
        template <typename Type>
        int Array<Type>::DefaultSize() 
            { 
                return m_size_default;
            }
 
        template<class Type>
        int Array<Type>::Size() const
        {
            return this->m_size; 
        }
 
        
        //----------- Implementaion of Modificator(s) member(s) function -----------//
 
        template <class Type>
        void Array<Type>::Swap(Array& ObjArray)
            {
                //std::swap()  - try to implement std swap function 
              Type* data = m_data;
       unsigned int size = m_size;
              m_data     = ObjArray.m_data;
              m_size     = ObjArray.m_size;
         ObjArray.m_data = data;
         ObjArray.m_size = size;
            }
 
        template <class Type> 
        void Array<Type>::SetElement(const Type& ObjType,unsigned int index)
            {
 
                    if (index >= m_size || index < 0 )
                        {
                            throw std:: out_of_range ("out of range error in void Array<Type>::SetElement");
                        }
                    m_data[index] = ObjType;
            //  std::cout << "Set Element <- " << ObjType  << std::endl;
            }
 
        template <typename Type>
        void Array<Type>::DefaultSize( int newSize) 
            { 
                m_size_default = newSize; 
            }
 
        //----------- Implementation of Operators Overloading the class's member -----------//
        
        template <class Type>
        Array<Type>& Array<Type>::operator = (const Array& ObjArray)
            {
              //Check self assign:
              if(this == &ObjArray) {return *this;}
 
              Array<Type> copy(ObjArray);   //Create a copy of ObjArray; If this fails, then *this will not be changed, and nothing will leak
 
                                            //Succeeded creating copy. Now we can put it inside this
              this->Swap(copy);             //And then swap the copy into this!
 
              return *this;
            }
 
        template <class Type> 
        Type& Array<Type>::operator [] (unsigned int index) 
            {
            //  std::cout << "Array [] operator" << std::endl;
 
                if (index >= this->m_size)
                    {
                        std::cout << "i am hreeeee" << std::endl;
                        return this->m_data[0];
                    }
                return m_data[index];
            }
 
        template <class Type> 
        const Type& Array<Type>::operator [] (unsigned int index) const
        {   
            if (index > this-> m_size)
                    {
                        std::cout 
                            << "OUT OF BOUND ";
                        return this->m_data[0];
                    }
            return m_data[index];
        }
 
 
 
    #endif //Array_CPP


NumericArray_cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
//                                                      
//                                                  (---.NumericArray_cpp---)
//  
 
    #ifndef NumericArray_CPP
    #define NumericArray_CPP
 
 
#include "NumericArray.hpp"
 
 
//template <class Type>
//Array<Type>::Array(); 
 
 
 
    template <class Type>
    NumericArray<Type>::NumericArray():Array() //: m_size(10), m_data(0) // default filling of array is zeros!
        {
                
        }
    
 
 
    template <class Type>
    NumericArray<Type>::NumericArray( int new_size): Array( new_size) //:Array() //: m_size(new_size), m_data(new Type[new_size])
    {
            
    }
 
            
            
        
 
    template <class Type>
    NumericArray<Type>& NumericArray<Type>::operator = (const NumericArray<Type>& ar) 
    {
         Array<Type>::operator = (ar);  // call base class assignment operator
         return *this;
    }
 
    template <class Type>
    NumericArray<Type>::~NumericArray()
    {
      //Technically, the if is not necessary
      if(m_data)
      {
        delete[] m_data;
        m_data = 0;
      }
      //Not necessary either, but just to be clean
      m_size = 0;
    }
 
    
 
    template<class Type>
    NumericArray<Type> NumericArray<Type>::operator *( double factor) const
    {
        
       NumericArray<Type> output(Array<Type>::Size());
       for(int i=0; i<Size(); i++)
       {
 
          output[i] = (*this)[i] * factor;
          //return output;
       }
       return output;
    }
        template<class Type>
     NumericArray<Type> NumericArray<Type>::operator +  (const NumericArray<Type>& ObjNumericArray) const
     {
 
       NumericArray<Type> output(Array<Type>::Size());
       for(int i=0; i<Size(); i++)
       {
          output[i] = (*this)[i] + ObjNumericArray[i];
       }
       return output;
     
     }
 
     template<class Type>
     NumericArray<Type>  NumericArray<Type>::operator * ( const NumericArray<Type>& ObjNumericArray) const
     
     {
     NumericArray<Type> output(Array<Type>::Size());
       for(int i=0; i<Size(); i++)
       {
          output[i] = (*this)[i] * ObjNumericArray[i];
       }
       return output;
 
     }
 
     /*
     template<class Type>
    Type& NumericArray<Type>::DotProduct (const NumericArray<Type> ObjNumericArray ) 
     {
        
       NumericArray<Type> output(Array<Type>::Size());
       Type ObjType; 
       for(int i=0; i<Size(); i++)
           {
               output[i] = (*this)[i] * ObjNumericArray[i];
               ObjType += output[i];
           }
 
        return ObjType; 
     
     }
 
     */
 
     template<class Type>
    void NumericArray<Type>::DotProduct (const NumericArray<Type> ObjNumericArray ) 
     {
        
       NumericArray<Type> output(Array<Type>::Size());
       Type ObjType; 
       for(int i=0; i<Size(); i++)
           {
               output[i] = (*this)[i] * ObjNumericArray[i];
               ObjType += output[i];
           }
 
       std::cout <<  ObjType; 
     
     }
 
 
 
 
#endif //NumericArray_cpp


Point_cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
//                                                      
//                                                  (---.Point_cpp---)
//  
    #include "Point.hpp"
 
 int number_of_point_constructor_calls          = 1 ;   
 int number_of_point_destructor_calls           = 1 ;  
 int number_of_point_assignment_operator_calls  = 1 ; 
 
 
                //----------- Implementation of Constructors -----------//
    Point::Point() : x(0) , y(0)            // Default constructor (implemented using colon syntax )                                    
            { 
            //  std::cout << "hi my default constructor\n\n\t";
            }                           
 
 
    Point::Point(const double newX ,const double newY) : x(newX)  , y(newY)     // Constructor 
            { 
        //      std::cout << " My Point constructor was called " << number_of_point_constructor_calls++ << " times " << "\n"; 
            }                   
 
    Point::Point(const double value ) : x(value)                // Second Constructor 
            { 
            //std::cout << "hi my constructor\n\n\t"; 
            }   
    Point::~Point()                                             // Destructor
            {
            //  std::cout << " My Point destructor was called " << number_of_point_destructor_calls++ << " times " << "\n"; 
            }                                    
 
    Point::Point (const Point& ObjectOfClassPoint)              // Copy constructor
            {
                //std::cout << "this is COPY constructor\n\n\t ";
                x = ObjectOfClassPoint.x;
                y = ObjectOfClassPoint.y;
            }
        
 
                //----------- Implementation of Accessor(s) member functions -----------//
    std::string Point::ToString() const
            {
            //  std::string s=Shape::ToString();                                
                std::ostringstream os;                          // std::stringstream object
                os << " Point (" << x << ", " << y << ") " ;    // customization of output and calling base class functuanality 
                return os.str();                                // str() function retrieve the string from the string buffer
            }
 
 
                //----------- Implementation of Calculators (additional functionality) member functions -----------//
    double  Point::Distance() const
 
            {
                return std::sqrt(pow(x,2) + pow(y,2));
            }
 
 
    double  Point::Distance(const Point   &ObjPt ) const
    
            {
                return std::sqrt(pow((x-ObjPt.x),2) + pow(y - ObjPt.y,2)); 
            }
 
 
            //----------- Implementation of Operators Overloading the class's member -----------//
    Point Point::operator  -  () const                                  // Negate the coordinates.          
        {
            return Point(-x,-y);
        }
 
    Point Point::operator  *  (double factor) const                     // Scale the coordinates.
        {
            return Point(x * factor, y * factor);
        }
 
    Point  Point::operator *  (const Point& ObjPoint) const                     // Scale the objects .
        { 
            return Point(x * ObjPoint.x, y * ObjPoint.y);
        }
 
 
    Point Point::operator  +  (const Point& ObjPoint) const             // Add coordinates.
        { 
            return Point(x + ObjPoint.x, y + ObjPoint.y);
        }
 
    bool Point::operator   == (const Point& ObjPoint) const             // Equally compare operator.    
        {
            return (x==ObjPoint.x)&(y==ObjPoint.y);
        }
 
    Point& Point::operator =  (const Point& ObjPoint)                           // Assignment operator.             
                {       
            //      std::cout << " My Point assignment operator was called " << number_of_point_assignment_operator_calls++ << " times " << "\n"; 
                    x=ObjPoint.x, y=ObjPoint.y;
                    return *this;                                               // The meaning of *this explained in this example (implementation) see comment out  
                }
 
    Point& Point::operator *= (double factor)                                   // Scale the coordinates & assign.      
        {
            x *= factor; 
            y *= factor;
 
            return *this ; 
        }
    
 
    Point& Point::operator += (const Point& ObjPoint)  
        {
                x += ObjPoint.x;
                y += ObjPoint.y;
 
                return *this;
        }
 
    Point& Point::operator -= (const Point& ObjPoint)
        {
                x -= ObjPoint.x;
                y -= ObjPoint.y;
 
                return *this;
        }
 
 
    //----------- Implementation of GLOBAL Ostream << Operator  -----------//
    std::ostream& operator << (std::ostream& out,const Point & ObjPoint)
            {
                return out << "[" << ObjPoint.x << "," << ObjPoint.y << "]" ; 
                
            }


main_cpp


C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
//
//                      (---.main_cpp---)
//
        #include "Point.hpp"
        #include "Array.cpp"
        #include <exception>
        #include "NumericArray.cpp"
        #include <iostream>
 
        
int main()
{
              //Create two Point arrays and test the operators
    NumericArray<Point> pArray1(5);
    NumericArray<Point> pArray2(5);
    
    
    //Array<Point> PointArray (5);
    //initialize
    //for (int i=0; i!=PointArray.Size(); i++ ) PointArray[i] = Point (2*i,2*i); 
    for(int i=0; i<pArray1.Size(); i++) pArray1[i] = Point(i, i);
    for(int i=0; i<pArray2.Size(); i++) pArray2[i] = Point(7*i, 4*i);
 
    //Numeric Array's operations not working for Point objects
 
 
    
     NumericArray<Point> PointArray(5);
        PointArray = pArray1 * 34 ;
        
     
    
    for(int i=0; i<PointArray.Size(); i++)
    {
        std::cout << PointArray[i] << std::endl;
    }
 
                    std::cout << "\nTEST of + operator.  PointArray + pArray2 \n"  << std::endl; 
    
 
    std::cout << "\n data both arrays  \n"  << std::endl;
     for(int i=1; i<PointArray.Size(); i++)
    {
        std::cout << pArray2[i] <<" + " << "" <<  PointArray[i] <<  std::endl;
    }
     PointArray = PointArray + pArray2; 
     std::cout << "\n NEW  PointArray Array \n"  << std::endl; 
     for(int i=1; i<PointArray.Size(); i++)
    {
        
        
        std::cout << PointArray[i] << std::endl;
    }
    
     std::cout << "\nTEST of * two NumericArray pArray1  pArray2 \n"  << std::endl; 
 
    
     NumericArray<Point> PointArray1(5);
    PointArray1 =  pArray1*pArray2; 
 
    std::cout << "\n NEW2  PointArray Array \n"  << std::endl; 
 
     for(int i=0; i<PointArray.Size(); i++)
 
            {
                std::cout << pArray1[i] <<"*"<<pArray2[i]<<"=" << PointArray1[i] << std::endl;
            }
 
      std::cout << "\nTEST DotProduct  \n"  << std::endl; 
 
    
 
//   std::cout <<  "DOT PRODUCT :  "  <<  pArray1.DotProduct(pArray2); 
      std::cout <<  "DOT PRODUCT :  " ;
    pArray1.DotProduct(pArray2); 
 
               std::cout << "\n\n\n";
               std::cout << "\n\n\n";
 
    return 0;
}
Миниатюры
Generic inheritance. Templates  
Jupiter
Каратель
Эксперт C++
6543 / 3963 / 226
Регистрация: 26.03.2010
Сообщений: 9,273
Записей в блоге: 1
Завершенные тесты: 2
03.08.2012, 17:14     Generic inheritance. Templates #17
Цитата Сообщение от Leeto Посмотреть сообщение
если делать ее void то все нормально если Type& то возвращает гов..окоординаты точки
возвращаешь ссылку на локальный объект, потому и мусор
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
03.08.2012, 17:53     Generic inheritance. Templates
Еще ссылки по теме:

C++ Variadic templates fail
Variadic templates C++
C++ Variadic templates

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 17:53  [ТС]     Generic inheritance. Templates #18
Причем только одна координата плохая вторую правильно считает

Добавлено через 38 минут
Цитата Сообщение от Jupiter Посмотреть сообщение
возвращаешь ссылку на локальный объект, потому и мусор
спасиб
Yandex
Объявления
03.08.2012, 17:53     Generic inheritance. Templates
Ответ Создать тему
Опции темы

Текущее время: 20:25. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru