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

Templates. (concrete inheritance). question to destructor implementation - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Составить правило http://www.cyberforum.ru/cpp-beginners/thread633343.html
как правильно составить условие для If выдать сообщения если введены не цифры
C++ string и функция _itow Всем привет! Ребята, не могу понять как мне использовать string и функцию _itow Вот код wstring positionclient = _itow( findclient.inumberhome,positionclient.c_str(),10 ); Пробовал использовать вот так, тоже не получается http://www.cyberforum.ru/cpp-beginners/thread633303.html
Виртуальные фукнции C++
Здравствуйте, уважаемые форумчане! Не получается реализовать следующее: Есть базовый класс Array с полями: массив типа unsigned char и поле для хранения количества элементов у текущего объекта-массива. Реализовать в классе Array виртуальную функцию поэлементного сложения массивов. Теперь дочерние классы: Класс Hex содержит число в шестнадцатеричной системе исчисления, при этом оно вводится в...
Опять про реализацию класса в отдельном файле C++
Допустимо ли следующее? есть проект в Visual Studio 2010. в нем следующие файлы: main.cpp - собссно программа MyClass.h - интерфейс класса MyClass MyClass.cpp - реализация класса MyClass MySubClass.h - интерфейс класса MySubClass (производного от MyClass) MySubClass.cpp - реализация класса MySubClass
C++ Размер вектора и вывод элементов http://www.cyberforum.ru/cpp-beginners/thread633285.html
Объясните почему в функции print размер передаваемого вектора v.size()=0? Соответсвенно не работает цикл for в print(). #include <iostream> #include <vector> using namespace std; void print(vector<int> v, string s) { cout << s << '\n'; cout << v.size() << '\n';
C++ Деление числа на разряды Дан массив из n натуральных четырёхзначных чисел. Вывести на экран только те, у которых сумма первых двух цифр равна сумме двух последних. Собственно сам вопрос, как разделить четырёхзначное число на тысячи, сотни, десятки и единицы? Пытался брать остаток от деление, например: 1734 % 10, но так получится отделить только единицы, а мне надо что бы число разложилось на 1, 7, 3 и 4. подробнее

Показать сообщение отдельно
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
05.08.2012, 18:46     Templates. (concrete inheritance). question to destructor implementation
Есть вот такой вот проект. Идея в том том что конкретный класс наследуется от темплейта.
Как в таком случае ПРАВИЛЬНО + ГРАМОТНО реализовать дестрактор у конкретного класса ???
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
PointArray::PointArray(int size) : Array<Point>(size)
        { 
 
        }
 
 
        PointArray::~PointArray() 
            {
            // /*1я версия Дестрактора */   Array<Point>::~Array(); 
 
 
            // /*2я версия Дестрактора */
              if(m_data)
                  {
                    delete[] m_data;
                    m_data = 0;
                  }
            
              m_size = 0;
             
            }

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
52
53
54
//                                                      
//                                                  (---.Array_hpp---)
//
#ifndef Array_HPP
#define Array_HPP
 
    #include <sstream>
    #include <iostream>
    #include <exception>
 
    template <class Type>   
    class Array
        {
    
            protected:                      
              unsigned int m_size;
              Type*        m_data;      
 
            public:                     
              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 ofOverloaded Operators  ------------//
              Array<Type>& operator =   (const Array& ObjArray);                //Const correctness here.
              const Type& operator  []  (unsigned int index) const;
              Type& operator        []  (unsigned int index);           
 
    //        */
        };
 
 
    #ifndef Array_cpp 
 
        #include "Array.cpp"
 
    #endif //#ifndef Array_cpp is CLOSED
 
#endif //  #ifndef Array_HPP is CLOSED


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


POINTARRAY_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
//                                                      
//                                                  (---.POINTARRAY_HPP---)
//
#ifndef PointArray_HPP
#define PointArray_HPP
 
    #include "Array.hpp"
    #include "Point.hpp"
    #include <math.h>
    #include <iostream>
    using namespace std; 
 
 
    class PointArray: public Array<Point>
 
    {
        public: 
            //----------- Declaration of Constructors -----------//
        
            PointArray() ;
            PointArray(int  size);
            ~PointArray();
 
           //----------- Declaration of Calculators (additional functionality) member functions -----------//
            double Lenght() ;
            
            //----------- Declaration of Overloaded Operators  ------------//
            PointArray& operator  =  (const PointArray& ar); 
            PointArray  operator  *  (double factor) const;   
            // PointArray& operator[] (int PointArray& index) const;
 
    };
 
 
    
 
#endif //  #ifndef Array_HPP is CLOSED


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
168
169
170
171
172
173
//                                                      
//                                                  (---.Array_CPP---)
//  
 
    #ifndef Array_CPP
    #define Array_CPP
 
            #include "Array.hpp"
            using namespace std;
 
 
        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 Overloaded Operators  ----------- //
 
            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
 
//      */


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 << "]" ; 
                
            }


PointArray_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
/*
#ifndef PointArray_CPP
#define PointArray_CPP
 
*/
 
        #include "PointArray.hpp"
        
 
    //----------- Implementation of Constructors -----------//
 
    PointArray::PointArray(): Array<Point>()
        {
 
        }
 
 
    PointArray::PointArray(int size) : Array<Point>(size)
        { 
 
        }
 
 
        PointArray::~PointArray() 
            {
            // /*1я версия Дестрактора */   Array<Point>::~Array(); 
 
 
            // /*2я версия Дестрактора */
              if(m_data)
                  {
                    delete[] m_data;
                    m_data = 0;
                  }
            
              m_size = 0;
             
            }
 
 
        
 
        //----------- Implementation of Calculators (additional functionality) member functions -----------//
        double  PointArray::Lenght() 
            {
                double output = 0 ;
                for(int i=1; i<PointArray::Size(); i++)
                    {
                        output += this->GetElement(i).Distance(this->GetElement(i-1)); 
                    }
                return output; 
            }
 
        // ----------- Implementation of Overloaded Operators  ----------- //
        
 
        PointArray& PointArray::operator = (const PointArray& ar) 
            {
                 Array<Point>::operator = (ar);  // call base class assignment operator
                 return *this;
            }
 
        
 
        PointArray PointArray::operator *(double factor) const
            {
               PointArray output(Array<Point>::Size());
               for(int i=0; i<Array::Size(); i++)
                   {
                      output[i] = (*this)[i] * factor;
                      //return output;
                   }
               return output;
            }
    
 
    /* 
    PointArray& PointArray::operator[] (int PointArray& index) const
        {
 
        }
 
        */
 
//#endif //PointArray_cpp
Миниатюры
Templates. (concrete inheritance). question to destructor implementation  
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
 
Текущее время: 06:25. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru