I find that I implement operator * in Array and NumericalArray
I commented out operator * from Array and what I get:
Why are you commenting out code that your program is calling?
You should stop commenting out code and address the real problem, which I've stated in my previous posts. Your issue is a linker issue, all because you're separating template code into its own compilation unit.
Why are you commenting out code that your program is calling?
You should stop commenting out code and address the real problem, which I've stated in my previous posts. Your issue is a linker issue, all because you're separating template code into its own compilation unit.
Why are you commenting out code that your program is calling?
You should stop commenting out code and address the real problem, which I've stated in my previous posts. Your issue is a linker issue, all because you're separating template code into its own compilation unit.
Regards,
Paul McKenzie
But I need that operator * will be in NumericArray not in Array template... because of this I commented out declaration and implementation operator * in Array. h and Array.cpp
Why is it wrong ?
BTW this result I get when I uncommented operator * in Array...
Why are you commenting out code that your program is calling?
You should stop commenting out code and address the real problem, which I've stated in my previous posts. Your issue is a linker issue, all because you're separating template code into its own compilation unit.
Regards,
Paul McKenzie
I mean from condition I should call operator * from NumericalArray not from Array
and relationship between those two template should be hierarchy (ISA if I not mistaken )
this is last edition :
Code:
//array.h //array.h //array.h //array.h //array.h //array.h //array.h //array.h //array.h //array.h
#ifndef Array_H
#define Array_H
template <class Type> //Remove the "=double" default parameter.
class Array
{
protected:
int m_size;
Type* m_data; //m_data should be a pointer, since you want to allocate data to it
public:
Array();
Array(int new_size);
virtual ~Array(); //Don't make your destructor virtual. There is no reason to do it.
Array<Type>& operator=(const Array& ar); //Const correctness here.
//Type& operator * (double factor) const;
Array operator *(double factor) const; //
Type& operator [] (int index);
const Type& operator [] (int index) const;
int Size() const;
};
#ifndef Array_cpp
#include "array.cpp"
#endif
#endif //Array_CPP
//*******************
//*******************
//*******************
//*******************
//NumericArray.h //NumericArray.h //NumericArray.h //NumericArray.h //NumericArray.h //NumericArray.h //NumericArray.h //NumericArray.h //NumericArray.h
#include "array.h"
#ifndef NumericArray_H
#define NumericArray_H
template <class Type> //Remove the "=double" default parameter.
class NumericArray: public Array<Type>
{
public:
NumericArray();
NumericArray(int new_size);
~NumericArray(); //Don't make your destructor virtual. There is no reason to do it.
//NumericArray<Type>& operator=(const Array& ar); //Const correctness here.
NumericArray operator *(double factor) const; //
};
#ifndef NumericArray_cpp
#include "NumericArray.cpp"
#endif
#endif // NumericArray
//*******************
//*******************
//*******************
//*******************
//point.h //point.h //point.h //point.h //point.h //point.h //point.h //point.h //point.h //point.h
#include "array.h"
#include <sstream>
#include <iostream>
using namespace std;
class Point
{
private:
double m_x;
double m_y;
public:
// Constructors
Point(): m_x(0), m_y(0) {};
Point(double new_x, double new_y) : m_x(new_x), m_y(new_y) {};
friend ostream& operator << (ostream& os, const Point& point)
{
return os << point.ToString();
}
//std::string Point::ToString(void) const // create a string representation of a point
string ToString() const
{
// create a string like: “Point(1.5, 3.9)”
std::ostringstream os;
os << m_x << " , " << m_y;
std::string double_string = os.str();
return "Point(" + double_string + ")";
}
//Point Point::operator * (double factor) const;
Point operator *(double factor) const;
//Point& Point::operator *= (double factor);
Point & operator *=(double factor);
};
//*******************
//*******************
//*******************
//*******************
//array.cpp //array.cpp //array.cpp //array.cpp //array.cpp //array.cpp //array.cpp //array.cpp
#include "Array.h"
#include <sstream>
#include <iostream>
#include <exception>
using namespace std;
#ifndef Array_CPP
#define Array_CPP
template <class Type>
Array<Type>::Array() : m_size(10), m_data(0) // странно получается, размер 10, а данных нет
{
}
template <class Type>
Array<Type>::Array(int new_size) : m_size(new_size), m_data(new Type[new_size])
{
}
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;
}
template <class Type>
Array<Type>& Array<Type>::operator=(const Array& ar)
{
//Check self assign:
if(this == &ar) {return *this;}
Array<Type> copy(ar); //Create a copy of ar; 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 [] (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 [] (int index) const
{
// 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>
int Array<Type>::Size() const
{
return this->m_size;
}
template<class Type>
//Type& Array<Type>::operator * (double factor) const
Array<Type> Array<Type>::operator *(double factor) const
{
Array<Type> output(Array<Type>::Size());
for(int i=0; i<Array::Size(); i++)
{
output[i] = (*this)[i] * factor;
//return output;
}
return output;
}
#endif //Array_CPP
//*******************
//*******************
//*******************
//*******************
//NumericArray.cpp //NumericArray.cpp //NumericArray.cpp //NumericArray.cpp //NumericArray.cpp //NumericArray.cpp //NumericArray.cpp //NumericArray.cpp
#include "NumericArray.h"
#include <sstream>
#include <iostream>
#include <exception>
#include "array.h"
using namespace std;
#ifndef NumericArray_CPP
#define NumericArray_CPP
#include "array.h"
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])
{
}
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(NumericArray<Type>::Size());
for(int i=0; i<Array::Size(); i++)
{
output[i] = (*this)[i] * factor;
//return output;
}
return output;
}
#endif //NumericArray_CPP
//*******************
//*******************
//*******************
//*******************
// Point.cpp // Point.cpp // Point.cpp // Point.cpp // Point.cpp // Point.cpp // Point.cpp // Point.cpp
#include "Point.h"
#include <sstream>
#include <iostream>
using namespace std;
Point Point::operator * (double factor) const
{
return Point(m_x * factor, m_y * factor);
}
Point& Point::operator *= (double factor)
{
Point tmp = (*this) * factor;
*this = tmp;
return *this;
}
//****************
//****************
//****************
//main.cpp //main.cpp //main.cpp //main.cpp //main.cpp //main.cpp //main.cpp //main.cpp
#include "point.h"
#include <iostream>
#include "array.cpp"
#include <exception>
#include "NumericArray.h"
using namespace std;
int main()
{
//Create two Point arrays and test the operators
Array<Point> pArray1(5);
Array<Point> pArray2(5);
//initialize
for(int i=0; i<pArray1.Size(); i++) pArray1[i] = Point(i, i);
for(int i=0; i<pArray2.Size(); i++) pArray2[i] = Point(2*i, 2*i);
//Numeric Array's operations not working for Point objects
cout << "times PointArray1 by 3 and print out the new array: "<< endl;
Array<Point> answ1 = pArray1 * 3;
for(int i=0; i<answ1.Size(); i++){
cout << answ1[i] << endl;
}
}
//*******************
//*******************
//*******************
//*******************
Last edited by oteel; June 19th, 2012 at 02:40 PM.
But I need that operator * will be in NumericArray not in Array template...
Why are you making this so difficult? Take that code in NumericArray.cpp and #include it in NumericArray.h.
How hard is that?
You also did not fix the issue with the included code outside of the include guards? Why not?
Also, take this out of NumericArray.cpp
Code:
#include "NumericArray.h"
Why are you #including NumericArray.h? You're supposed to be taking this code in NumericArray.cpp and including it in NumericArray.h, not the other way around.
Let's make this simple -- put everything in one file, NumericArray.h and delete, erase, get rid of NumericArray.cpp Now we have no NumericArray.cpp to confuse you.
Now NumericArray.h looks like this:
Code:
#ifndef NumericArray_H
#define NumericArray_H
#include "array.h"
template <class Type>
class NumericArray: public Array<Type>
{
public:
NumericArray();
NumericArray(int new_size);
~NumericArray(); //Don't make your destructor virtual. There is no reason to do it.
NumericArray<Type>& operator=(const Array<Type>& ar);
NumericArray operator *(double factor) const;
};
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])
{
}
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(NumericArray<Type>::Size());
for(int i=0; i<Array::Size(); i++)
{
output[i] = (*this)[i] * factor;
//return output;
}
return output;
}
template <class Type>
NumericArray<Type>& NumericArray<Type>::operator=(const Array& ar)
#endif
Understand now? Forget about NumericArray.cpp and just do the above.
Now that we have the code above, why are you duplicating exactly the same code from the Array class? You are deriving from the Array class, so why are you duplicating the code? Just call the parent Array class instead of rewriting everything.
Secondly, your assignment operator is not correct. It must take a NumericArray<Type> reference as a parameter, not an Array<Type>.
You also did not fix the issue with the included code outside of the include guards? Why not?
I thought that this is putting #include files like h and cpp after #define and #ifndef ??? or I'm mistaken
Understand now? Forget about NumericArray.cpp and just do the above.
Done
Secondly, your assignment operator is not correct. It must take a NumericArray<Type> reference as a parameter, not an Array<Type>.
done
Now that we have the code above, why are you duplicating exactly the same code from the Array class? You are deriving from the Array class, so why are you duplicating the code? Just call the parent Array class instead of rewriting everything.
I thought that this is putting #include files like h and cpp after #define and #ifndef ??? or I'm mistaken
No.
Just put the include file within the include guards. It makes no sense to have an include file, and some of it is sticking outside of the include guards -- plain and simple.
So you cannot fix this error? At some point you'll have to take the lead and fix your own compiler errors. You can't just repeatedly get a compiler error and not know what to do.
What do you think is the problem?
Also, it would help if you placed your code in individual code blocks, and not have everything placed in a single code block. No one can tell what is an individual module, where one file starts and one file ends, etc... Then you don't need comments like this:
Code:
// array.h array.h array.h array.h
Regards,
Paul McKenzie
Last edited by Paul McKenzie; June 20th, 2012 at 03:59 AM.
Problem with my brain... after one year of practice I'll be laugh about those posts and threads...
It happen every time that I try to learn some new for me big stuff...
okey I'm done previous mistake... There weren't realization of assignment operator if shortly
no there is other one problem...
1>------ Build started: Project: HP3_4.2b_ex2_with_inheritance, Configuration: Release Win32 ------
1> main.cpp
1>c:\all my\с++\ha level 6\solution\level 6\hp3_4.2b_ex2_with_inheritance\NumericArray.h(30): error C2614: 'NumericArray<Type>' : illegal member initialization: 'm_data' is not a base or member
1> with
1> [
1> Type=Point
1> ]
1> c:\all my\с++\ha level 6\solution\level 6\hp3_4.2b_ex2_with_inheritance\NumericArray.h(29) : while compiling class template member function 'NumericArray<Type>::NumericArray(int)'
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\с++\ha level 6\solution\level 6\hp3_4.2b_ex2_with_inheritance\NumericArray.h(30): error C2614: 'NumericArray<Type>' : illegal member initialization: 'm_size' is not a base or member
1> with
1> [
1> Type=Point
1> ]
1>c:\all my\с++\ha level 6\solution\level 6\hp3_4.2b_ex2_with_inheritance\NumericArray.h(66): warning C4172: returning address of local variable or temporary
1> c:\all my\с++\ha level 6\solution\level 6\hp3_4.2b_ex2_with_inheritance\NumericArray.h(59) : while compiling class template member function 'NumericArray<Type> &NumericArray<Type>:perator *(double) const'
1> with
1> [
1> Type=Point
1> ]
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========
"'m_data' is not a base or member" BUT WHY ???
I'm realize inherent and made data member on parents template protected (not private)... What is wrong again ?
PS this is realization of assignment operator in NumerArray.h
Code:
template <class Type>
NumericArray<Type>& NumericArray<Type>::operator=(const NumericArray& ar)
{
//Check self assign:
if(this == &ar) {return *this;}
Array<Type> copy(ar); //Create a copy of ar; 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;
}
Second, and again, why are you repeating code that is already in the Array parent class? Do you not see that you're copying and pasting code from Array into NumericArray? Doesn't that sound wasteful to you?
Code:
template <class Type>
NumericArray<Type>& NumericArray<Type>::operator=(const NumericArray<Type>& ar)
{
Array<Type>::operator = (ar); // call base class assignment operator
return *this;
}
The bottom line is this --
You have a base class, it does work. You derive from that base class, so why don't you make the base class do its work? Instead, you're copying that work and putting it in the derived class. Why are you doing that?
That's legal code right there actually, as far as I'm concerned.
Originally Posted by oteel
"'m_data' is not a base or member" BUT WHY ???
I'm realize inherent and made data member on parents template protected (not private)... What is wrong again ?
m_data is a member of "Array", which means it is owned and constructed by Array, in Array's constuctor. While NumericArray can manipulate that member afterwards, it can't construct it.
Is your question related to IO?
Read this C++ FAQ LITE article at parashift by Marshall Cline. In particular points 1-6.
It will explain how to correctly deal with IO, how to validate input, and why you shouldn't count on "while(!in.eof())". And it always makes for excellent reading.
You have a base class, it does work. You derive from that base class, so why don't you make the base class do its work? Instead, you're copying that work and putting it in the derived class. Why are you doing that?
I don't understand question sorry... and I don't understand what difference between your and my implementation assignment operator... more compact and more logic because call base class assignment ??? I not sure that my implementation incorrect... but it's lyrical digression... i suppose because the mistake is still the same
That's legal code right there actually, as far as I'm concerned.
m_data is a member of "Array", which means it is owned and constructed by Array, in Array's constuctor. While NumericArray can manipulate that member afterwards, it can't construct it.
I don't understand question sorry... and I don't understand what difference between your and my implementation assignment operator... more compact and more logic because call base class assignment ???
The idea is this
You are to assume that you have no idea how the parent class makes copies.. This means that the only choice you have is to call the parent class assignment operator.
What if the parent class assignment operator changes? Are you going to fix your code trying to make those same changes in NumericArray? Why do that? Just call the parent assignment operator and let it do its work, whatever that work is.
When you make a copy, you're supposed to make sure that the parent make its copy too. Your code did not do that, instead you just copied and pasted what the parent class did. What if the assignment in the parent was a 1,000 line function? Are you going to copy and paste 1,000 lines of code in your NumericArray assignment operator?
You make the exact same mistake with your destructor -- why are you doing the work that the Array base class will do? Just let the Array class destructor do its job -- there is no need for you to duplicate code.
Regards,
Paul McKenzie
Last edited by Paul McKenzie; June 20th, 2012 at 05:25 AM.
Originally Posted by oteel
Reply With Quote
perator *(double) const'
Bookmarks