Thanks and excuse me, but now another problem

[Piotre Ugrumov]

Excuse me for the previous post, I have tried to modify the classes of the
Savannah example and now I succeed to compile the classes but I have a
strange problem.

When I declar an object of the class Savan, I cannot see the methdo of the
class:
Savan s();
Leone l(........);
s.addLeone(l);
the methdo addLeone() isn't view, but all the method of the class Savan
aren't view.
//Savan s();
//s.addLeone(l);
error C2228: the element on the left ".addLeone" must have a type class,
structure or union
the type is "overloaded-function"
Why this behaviour?
If I define a constructor like this Savan(Leone &l, Zebra &z), I can view
and I can use all the methods.
//Savan s(l, z);
//s.addLeone(d);
In this way I don't receiver message error, but When I start the program all
is blocked
This constructor is implemented in this way:

Savan::Savan(Leone &l, Zebra &z){
addLeone(l);
addZebra(z);
}

Another question:
How can I do to add an object to a dynamic array:
I have defined 2 pointer and two int:

Leone *lPtr;
Zebra *zPtr;
int lsize, zsize;

For add an object to lPtr or zPtr, I have defined the method in this way:
void Savan::addLeone(Leone &l){
Leone *tmp;
tmp=lPtr;
lsize=lsize+1;
lPtr=new Leone[lsize];
lPtr=tmp;
lPtr[lsize-1]=l;
delete[] tmp;
}
Is correct what I write?
The constructor without arguments inizialize lPtr=0; zPtr=0; lsize=0;
zsize=0;

Thanks and excuse me.

[Rolf Magnus]

Piotre Ugrumov wrote:

Excuse me for the previous post, I have tried to modify the classes of
the Savannah example and now I succeed to compile the classes but I
have a strange problem.

When I declar an object of the class Savan, I cannot see the methdo of
the class:
Savan s();
This declares a function named s that takes no parameters and returns an
object of type Savan.
Leone l(........);
s.addLeone(l);
the methdo addLeone() isn't view, but all the method of the class
Savan aren't view.
//Savan s();
//s.addLeone(l);
error C2228: the element on the left ".addLeone" must have a type
class, structure or union
the type is "overloaded-function"
Why this behaviour?
Because s actually is a function. Try teplacing it with:

Savan s;
If I define a constructor like this Savan(Leone &l, Zebra &z), I can
view and I can use all the methods.
//Savan s(l, z);
This defines an object of type Savan that is initialized with the values
l and z.
//s.addLeone(d);
In this way I don't receiver message error, but When I start the
program all is blocked
This constructor is implemented in this way:

Savan::Savan(Leone &l, Zebra &z){
addLeone(l);
addZebra(z);
}

Another question:
How can I do to add an object to a dynamic array:
I have defined 2 pointer and two int:

Leone *lPtr;
Zebra *zPtr;
int lsize, zsize;

For add an object to lPtr or zPtr, I have defined the method in this
way: void Savan::addLeone(Leone &l){
Leone *tmp;
tmp=lPtr;
lsize=lsize+1;
lPtr=new Leone[lsize];
lPtr=tmp;
lPtr[lsize-1]=l;
delete[] tmp;
}
Is correct what I write?

You lose all the objects that were in the old array, since you don't
copy them to the new location. Besides that, the code is not very
efficient, since it needs to reallocate for every object added. I
suggest to use std::vector instead of arrays. std::vector has all the
functionality for resizing already implemented and is probably a lot
faster than your code, since it does the reallocation and copying in
blocks so that it doesn't need to do them for every object. Just define
them as:

std::vector<Leone> lVector;
std::vector<Zebra> zVector;

And your addLeone funciton would look like:

void Savan::addLeone(Leone &l){
lVector.push_back(l);
}

You can access the object the same way as with an array, using the []
operator.

[Martijn Lievaart]

On Mon, 19 Jan 2004 10:02:19 +0000, Piotre Ugrumov wrote:

Excuse me for the previous post, I have tried to modify the classes of the
Savannah example and now I succeed to compile the classes but I have a
strange problem.

When I declar an object of the class Savan, I cannot see the methdo of the
class:
Savan s();
Surprise! This declares a function s, taking no arguments and returning a
Savan. The rule is, if it can declare a function, it declares a function.
Leone l(........);
s.addLeone(l);
And we cannot use '.' on a function, so the compiler rightly complains.

Change:
Savan s();
to
Savan s;
and it should work.
If I define a constructor like this Savan(Leone &l, Zebra &z), I can view
and I can use all the methods.
//Savan s(l, z);
This cannot be a function declaration, so it must be an variable
definition. That is why this works.
Another question:
How can I do to add an object to a dynamic array:
I have defined 2 pointer and two int:

Leone *lPtr;
Zebra *zPtr;
int lsize, zsize;

For add an object to lPtr or zPtr, I have defined the method in this way:
void Savan::addLeone(Leone &l){
Leone *tmp;
tmp=lPtr;
lsize=lsize+1;
lPtr=new Leone[lsize];
lPtr=tmp;
lPtr[lsize-1]=l;
delete[] tmp;
}
Is correct what I write?
The constructor without arguments inizialize lPtr=0; zPtr=0; lsize=0;
zsize=0;

Uch! No, it's not. You never copy the elements. Why not use a std::vector
or a std::list? They resize automagically.

std::vector<Leone> LeoneVector;

void Savan::addLeone(const Leone &l){
LeoneVector.push_back(l);
}

HTH,
M4

[Karl Heinz Buchegger]

Piotre Ugrumov wrote:

Excuse me for the previous post, I have tried to modify the classes of the
Savannah example and now I succeed to compile the classes but I have a
strange problem.

When I declar an object of the class Savan, I cannot see the methdo of the
class:
Savan s();
This does *not* define an object. It does something completely different:
It declares a function s, which takes no arguments and returns a Savan object.

You want:
Savan s;
Leone l(........);
s.addLeone(l);
the methdo addLeone() isn't view, but all the method of the class Savan
aren't view.
//Savan s();
//s.addLeone(l);
error C2228: the element on the left ".addLeone" must have a type class,
structure or union
the type is "overloaded-function"
Why this behaviour?
Because there is a C++ rule: if something could be a function declaration,
then it *is* a function declaration (a prototype).

Savan s();

looks like a function declaration in the same way as eg.

double MyFunction();

does. Thus the compiler treats it as such.

Another question:
How can I do to add an object to a dynamic array:
I have defined 2 pointer and two int:

Leone *lPtr;
Zebra *zPtr;
int lsize, zsize;

For add an object to lPtr or zPtr, I have defined the method in this way:
void Savan::addLeone(Leone &l){
Leone *tmp;
tmp=lPtr;
lsize=lsize+1;
lPtr=new Leone[lsize];
lPtr=tmp;
lPtr[lsize-1]=l;
delete[] tmp;
}
Is correct what I write?

No.

void Savan::addLeone(Leone &l)
{
Leone* tmp;

tmp = lPtr;

lptr = new Leone[lsize + 1];
for( int i = 0; i < lsize; ++i ) {
lptr[i] = tmp[i];
}
lsize++;

lptr[lsize-1] = l;
delete [] tmp;
}

But even now, there are things that can go wrong (eg. what happens
if the memory allocation failes).

Given your current knowledge, it's best to not do the dynamic memory
management by yourself (there are lots of pitfalls), but instead let
a prebuilt class do it. C++ comes with such a class and it is called vector

#include <string>
#include <vector>
#include <iostream>

class Item
{
public:
Item( const std::string& Name ) : m_Name( Name ) {}
std::string Name() { return m_Name; }

private:
std::string m_Name;
};

class MyTest
{
public:
void Add( const Item& NewItem )
{
m_Items.push_back( NewItem );
}

void PrintAll()
{
for( int i = 0; i < m_Items.size(); ++i )
std::cout << m_Items[i].Name() << '\n';
}

private:
std::vector< Item > m_Items;
};

int main()
{
MyTest TheContainer;
Item Chest( "Chest" );

TheContainer.Add( Chest );
TheContainer.Add( Item( "Chair" ) );
TheContainer.Add( Item( "Lion" ) );

TheContainer.PrintAll();

return 0;
}

--
Karl Heinz Buchegger
kb******@gascad.at