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

Generic inheritance. Templates - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ В каких вариантах выпускался c++ 6 без подержки net http://www.cyberforum.ru/cpp-beginners/thread632325.html
В каких вариантах выпускался c++ 6 без подержки net
C++ Матрицы. Классы. Проверка ввода Все привет. Нужно реализовать класс матриц. Почти всё сделал. Но не могу понять, что у меня за ошибка при проверке ввода? Вот вывод и код программы с комментариями. Подскажите, если кто знает, что за цикл непонятного происхождения у меня в консоли? #include <iostream> #include <time.h> #include <conio.h> using namespace std; class Matrix{ http://www.cyberforum.ru/cpp-beginners/thread632309.html
Ошибка функции max () | min() C++
Задача: Дано три числа, записанный в отдельных строках. Упорядочите их в порядке убывания. Программа должна считывать три числа a, b, c, затем программа должна менять их значения так, чтобы стали выполнены условия a <= b <= c, затем программа выводит тройку a, b, c. Я хочу решить его таким способом... Но возникает проблема при компиляции... Почему? #include <iostream> #include <cmath>...
C++ Написать программу, результат работы которой - округление дробного числа до целого по математическим правилам.
Здравствуйте, Друзья. Задание: Написать программу, результат работы которой - округление дробного числа до целого по математическим правилам. Вот код #include <iostream> using namespace std; void Okruglenie(float); void main() {
C++ rand http://www.cyberforum.ru/cpp-beginners/thread632289.html
srand(time(NULL)); int s = rand()%1000 +1; генерирует бред вроде 3,4,7,10,14,19,21,26,29... как сделать чтобы значения были примерно такие : 458,985,100,5,857,40,756
C++ Реализация комбинаторики Задача имеет следующий вид. Есть набор строка символов неопределенной(заранее) длины. Нужно из данной строки подсчитать и вывести все варианты возможных комбинаций от одного символа и до length(str). Подсчитать кол-во вариантов не проблема (\sum_{i=0}^{length}\frac{length!}{i!*(length-i)!}) - проблема в переборе все возможных вариантов. Прошу помочь с алгоритмом. Используется C++.... подробнее

Показать сообщение отдельно
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
03.08.2012, 17:12  [ТС]     Generic inheritance. Templates
Цитата Сообщение от 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  
 
Текущее время: 09:22. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru