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

Copy Constructor Question .Generic inheritance. Templates - C++

Восстановить пароль Регистрация
 
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
06.08.2012, 12:53     Copy Constructor Question .Generic inheritance. Templates #1
Допустим есть проект

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
//                                                      
//                                                  (---.Array_hpp---)
//
#ifndef Array_HPP   // Preprocessor gates
#define Array_HPP
 
    #include <sstream>
    #include <iostream>
    #include "ArrayException.hpp"
 
    template <class T>  //Remove the "=double" default parameter.
    class Array
        {
    
            protected:              // Declaration of private data members 
             unsigned int m_size;
              T*           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<T>& ObjArray);          // Copy constructor
              ~Array();                                 // Destructor
 
               //----------- Declaration of Modificator(s) member functions -----------//
              void SetElement(const T& ObjType, const unsigned int index);
              static void DefaultSize( int newSize) ;
 
              //----------- Declaration of  Accessors member functions -----------//
              T& GetElement(const unsigned int index) const;
              static int  DefaultSize() ;
              int Size() const;
              
 
              //----------- Declaration of Operators Overloading the class's members -----------//
              Array<T>& operator    =   (const Array& ObjArray);                //Const correctness here.
              const T& operator  [] (unsigned int index) const;
              T& 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
 
#endif //  #ifndef Array_HPP is CLOSED


ArrayException_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
//                                                      
//                                                  (---.ArrayException_hpp---)
//
#ifndef ArrayException_HPP
#define ArrayException_HPP
 
    class ArrayException 
    {
    public : 
        ArrayException(){};
        virtual std::string GetMessage() const = 0;
    };  
 
    class OutOfBoundsException : public ArrayException
    {
    private : 
         int array_index;
    public : 
        OutOfBoundsException();
        OutOfBoundsException(int index) : array_index(index) {}
        std::string GetMessage() const
        
        {
 
        std::ostringstream os;      // std::stringstream object
                    os  <<  "\nEXCEPTION HANDLING ERROR: "
                        << "the given element " 
                        << "with index : " 
                        << array_index 
                        << " is out of bounds\n "   ;
 
                    return os.str();    
        }
 
    };
#endif // ArrayException_H


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
//                                                      
//                                                  (---.NumericArray_hpp---)
//
#ifndef NUMERICARRAY_HPP
#define NUMERICARRAY_HPP
 
#include "Array.hpp"
 
    template <class T> 
    class NumericArray: public Array<T>
 
        {
            public: 
                 //----------- Declaration of Constructors -----------//
                 NumericArray();
                 NumericArray(int new_size);
                 ~NumericArray(); 
 
                 //----------- Declaration of Calculator(s) (additional functionality) member(s) function -----------//
                 T DotProduct (const NumericArray<T> ObjFirstNumericArray ) ;
        
                 //----------- Declaration of Overloaded Operator(s) -----------//
                 NumericArray<T>& operator = (const NumericArray<T>& ObjNumericArray); 
                 NumericArray<T>  operator * ( double factor) const;    
                 NumericArray<T>  operator * ( const NumericArray<T>& ObjNumericArray) const;   
                 NumericArray<T>  operator +  (const NumericArray<T>& 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_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
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
//                                                      
//                                                  (---.Array_CPP---)
//  
    #ifndef Array_CPP   // Preprocessor gates
    #define Array_CPP
 
        #include "Array.hpp"
        
 
        template <class T>
        int Array<T>::m_size_default = 10;
 
                    //----------- Implementation of Constructors -----------//
        template <class T>
        Array<T>::Array() :  m_size(10), m_data(new T[m_size])                                    
            {
            //  std::cout << "Array Default Constructor was called " ;
            }
 
        template <class T>
        Array<T>::Array(const unsigned int new_size) : m_size(new_size), m_data(new T[new_size])
            {    //specified by the size input argument                 
            //  std::cout << "Array Constructor was called "; 
            }
 
        template <class T>
        Array<T>::Array(const Array& ObjArray) : m_data(0), m_size(0)
            {
                 // std::cout << "Array copy Constructor "; 
                m_size    =    ObjArray.m_size;         // shallow copy - this is not dynamic alloc
                if (ObjArray.m_data)                    // if not zeros then there is a ref. - Deep copy needed
                    {
                        m_data = new T[ObjArray.m_size];
                        for (int i = 0; i <   ObjArray.m_size; i++)
                        m_data[i]    =    ObjArray.m_data[i];
                    }
                else
                m_data = 0;                             //NULL
            }
 
        template <class T>
        Array<T>::~Array()
            {
            //  std::cout << "Array Destructor was called\n" ;
                delete [] m_data;
            }
 
        //----------- Implementaion of Modificator(s) member(s) function -----------//
        template <class T> 
        void Array<T>::SetElement(const T& ObjType,unsigned int index)
            {
                    std::cout << "Set Element[" << index << "]<-   "; 
                    if (index >= m_size || index < 0 )
                        {   
                            std::cout << " Data wasn't setted"; 
                            throw OutOfBoundsException(index);
                        }
                    m_data[index] = ObjType;
            }
 
        template <typename T>
        void Array<T>::DefaultSize( int newSize) 
            { 
                m_size_default = newSize; 
            }
 
        //----------- Implementation of Accessor(s) member functions -----------//
        template <class T> 
        T& Array<T>::GetElement(const unsigned int index) const
            {
                std::cout << "GetElement[" << index <<"] ->" ;
                    if (index >= m_size || index < 0)
                        {       
                            std::cout << " Data wasn't getted"; 
                            throw OutOfBoundsException(index);
                        }
 
                return m_data[index];
            }
 
        template <typename T>
        int Array<T>::DefaultSize() 
            { 
                return m_size_default;
            }
 
        template<class T>
        int Array<T>::Size() const
        {
            return this->m_size; 
        }
 
        
 
        //----------- Implementation of Operators Overloading the class's member -----------//
 
        template <class T>
        Array<T>& Array<T>::operator = (const Array& ObjArray)
            {
             // std::cout << " Array Assignment operator\n";
            if (this == &ObjArray)
                {
                    //std::cout << "Same Array \n"; 
                    return *this;
                }
 
            delete [] m_data;
            // std::cout << "Deleted m_data array\n";
 
            m_size = ObjArray.m_size;       // shallow copy - this is not dynamic alloc
 
            if (ObjArray.m_data)            // if not zeros then there is a ref.
                    {
                        // std::cout <<"im here\n"; 
 
                        m_data = new T[ObjArray.m_size];        // create a new pointee.
 
                        for (unsigned int i = 0; i <    ObjArray.m_size; i++)
                        m_data[i]    =    ObjArray.m_data[i];   //copy the points from/to array
                    }
            else
                m_data = 0;  //NULL
 
            return *this;
            }
 
        template <class T> 
        T& Array<T>::operator [] (unsigned int index) 
            {
                //std::cout << "Array [] operator" << std::endl;
 
                if (index >= this->m_size)
                        { 
                            throw OutOfBoundsException(index);
                        }
                return m_data[index];
            }
 
        template <class T> 
        const T& Array<T>::operator [] (unsigned int index) const
        {   
            //std::cout << "const Array [] operator" << std::endl;
            if (index > this-> m_size)
                        { 
                            throw OutOfBoundsException(index);
                        }
            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
//                                                      
//                                                  (---.NumericArray_cpp---)
//  
    #ifndef NumericArray_CPP
    #define NumericArray_CPP
 
#include "NumericArray.hpp"
 
    template <class T>
    NumericArray<T>::NumericArray():Array() 
        {
                
        }
    
    template <class T>
    NumericArray<T>::NumericArray( int new_size): Array( new_size) 
    {
            
    }
 
    template <class T>
    NumericArray<T>& NumericArray<T>::operator = (const NumericArray<T>& ar) 
    {
         Array<T>::operator = (ar);  // call base class assignment operator
         return *this;
    }
 
    template <class T>
    NumericArray<T>::~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 T>
    NumericArray<T> NumericArray<T>::operator *( double factor) const
        {
           NumericArray<T> output(Array<T>::Size());
           for(int i=0; i<Size(); i++)
           {
 
              output[i] = (*this)[i] * factor;
              //return output;
           }
           return output;
        }
 
        template<class T>
     NumericArray<T> NumericArray<T>::operator +  (const NumericArray<T>& ObjNumericArray) const
         {
 
           NumericArray<T> output(Array<T>::Size());
           for(int i=0; i<Size(); i++)
               {
                  output[i] = (*this)[i] + ObjNumericArray[i];
               }
           return output;
     
         }
 
     template<class T>
     NumericArray<T>  NumericArray<T>::operator * ( const NumericArray<T>& ObjNumericArray) const
         {
         NumericArray<T> output(Array<T>::Size());
           for(int i=0; i<Size(); i++)
               {
                  output[i] = (*this)[i] * ObjNumericArray[i];
          
               }
           return output;
 
         }
 
     template<class T>
    T NumericArray<T>::DotProduct (const NumericArray<T> ObjNumericArray ) 
         {
           NumericArray<T> output(Array<T>::Size());
           T ObjType; 
           for(int i=0; i<Size(); i++)
               {
                   output[i] = (*this)[i] * ObjNumericArray[i];
                   ObjType += output[i];
               }
 
            return ObjType; 
         }
 
#endif //NumericArray_cpp is closed


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



Допустим у класса Array есть копи констрактор
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
template <class T>
        Array<T>::Array(const Array& ObjArray) : m_data(0), m_size(0)
            {
                 // std::cout << "Array copy Constructor "; 
                m_size    =    ObjArray.m_size;         // shallow copy - this is not dynamic alloc
                if (ObjArray.m_data)                    // if not zeros then there is a ref. - Deep copy needed
                    {
                        m_data = new T[ObjArray.m_size];
                        for (int i = 0; i <   ObjArray.m_size; i++)
                        m_data[i]    =    ObjArray.m_data[i];
                    }
                else
                m_data = 0;                             //NULL
            }
 
        template <class T>
        Array<T>::~Array()
            {
            //  std::cout << "Array Destructor was called\n" ;
                delete [] m_data;
            }
Начал переходить с одной имплементации Array на другую смотрю компилятор ругается на не знакомую ошибку какую то мол m_size bla bla inicialaze list (ща компелятор уже по другому ругается к сожалению ) и лайн на копи констрактор выдает
Открыл бек ап оказалось что ошибка заключалось в отсутствии вот этого
Array<T>::Array(const Array& ObjArray) : m_data(0), m_size(0)

Ну допустим окей правила игры такие при создании копи констрактора но мне смущает что там нули стоят (как то криво смотрится ). Ребят подскажи кто на самом деле там должно быть а ля как в конструкторе типа :
C++
1
: m_size(new_size), m_data(new T[new_size])
или как в дефолтном конструкторе
C++
1
:  m_size(10), m_data(new T[m_size])
или все таки нули должны быть ????

Добавлено через 11 минут
Не что то я попутал... похоже что эта хрень (: m_data(0), m_size(0)) не нужна вообще... или я ошибаюсь ???
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
06.08.2012, 12:53     Copy Constructor Question .Generic inheritance. Templates
Посмотрите здесь:

C++ copy constructor operator=
this и Copy-Constructor C++
Copy-Constructor В Шаблонном Связном списке C++
C++ Deep copy and Shadow copy
C++ Generic inheritance. Templates
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
ForEveR
Модератор
Эксперт C++
 Аватар для ForEveR
7927 / 4709 / 318
Регистрация: 24.06.2010
Сообщений: 10,524
Завершенные тесты: 3
06.08.2012, 13:03     Copy Constructor Question .Generic inheritance. Templates #2
C++
1
for (int i = 0; i <   ObjArray.m_size; i++)
m_size - unsigned int.
i - int.
Сравнение беззнакового целого со знаковым, что является не особо корректным.

Добавлено через 13 секунд
C++
1
for (int i = 0; i <   ObjArray.m_size; i++)
m_size - unsigned int.
i - int.
Сравнение беззнакового целого со знаковым, что является не особо корректным.
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
06.08.2012, 13:08  [ТС]     Copy Constructor Question .Generic inheritance. Templates #3
Еще такой вопрос если я делаю self-made ArrayException
обязательно в мейне делать трай катсч блок
или если я без него обойдусь то это не будет смотреться как плохой тон
с учетом того что я до этого уже показывал что этот эксепшен хенделинг нормально работает и все такое ????
ForEveR
Модератор
Эксперт C++
 Аватар для ForEveR
7927 / 4709 / 318
Регистрация: 24.06.2010
Сообщений: 10,524
Завершенные тесты: 3
06.08.2012, 13:14     Copy Constructor Question .Generic inheritance. Templates #4
Leeto, Не считаю, что краш программы может быть нормальным выходом. Так что try-catch таки нужен.
Yandex
Объявления
06.08.2012, 13:14     Copy Constructor Question .Generic inheritance. Templates
Ответ Создать тему
Опции темы

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