noobs and pointers

[Randy]

Hi,

I am a noob. I am trying to store Student objects pointers, in a
vector, within a School object.
I call a setter function to add the pointer. If I use this method it
works,
Student st = Student("Randy" );
Student * stp = & st;
sc.addStudent(s tp);

My problem is passing a Student to the School function. I have an
overridden function. I try to create a pointer from the passed
Student. I bet that's my problem because it's a copy ?

This all came about because I want to have a more succinct method for
doing this, just like the big kids do:
Student st = Student("Randy" );
Student * stp = & st;
sc.addStudent(s tp);

I've read lots but am apperantly missing the point. I am referencing
the C++ Primer.
here's my output too ... 2 Bills ?? ahaha ...

Schools Constructor 1
Student Constructor2 Randy
Overload addStudent1()
Student Constructor2 Biff
Overload addStudent3()
Student Constructor2 Bill
Overload addStudent1()
*** List ***
1 Randy
3 Bill
3 Bill
*** EOF ***
Press any key to continue . . .

main.cpp
---------------------------------------------------------------------------------------

#include <cstdlib>
#include <iostream>
#include <vector>

// #include "Templates. h"
// #include "PointersAndRef erence.h"
#include "StudentsAndSch ools.h"
using namespace std;

int main(int argc, char *argv[])
{
// mypair<intok(10 ,23); // Declare an INT class w/
construction
// ok.printValues( );
// referenceTests( );

School sc;
sc.setNames("Pa rkside");

Student st = Student("Randy" );
Student * stp = & st;
sc.addStudent(s tp);

sc.addStudent(S tudent("Biff")) ;

Student st1 = Student("Bill") ;
Student * stp1 = & st1;
sc.addStudent(s tp1);
sc.getStudentNa mes();

system("PAUSE") ;
return EXIT_SUCCESS;
}

--------------- StudentsAndScho ols.h
-------------------------------------------------------------

#ifndef __StudentsAndSc hools__
#define __StudentsAndSc hools__

using namespace std;
class School;

class Student {

private:
static int mLastId;
string mName;
int mId;
School * mSchool;

public:
Student(){
cout << "Student Constructor1" << endl;
}
Student(string n){
cout << "Student Constructor2 " << n << endl;
mName = n;
mId = ++mLastId;
}
void setName(string n);
string getName();
int getId();
};
int Student::mLastI d = 0;

string Student::getNam e(){ return mName; };
int Student::getId( ){ return mId; };

class School{

private:
string mName;
vector<Student* mStudents;

public:
School(){
cout << "Schools Constructor 1" << endl;
}
void addStudent(Stud ent* );
void addStudent(Stud ent &); // overloaded
function
void addStudent(Stud ent);

void setNames(string n);
void getStudentNames ();
};

void School::setName s(string n){
mName = n;
}
void School::addStud ent(Student* n){
cout << "Overload addStudent1()" << endl;
mStudents.push_ back(n);
}
void School::addStud ent(Student &n ){
cout << "Overload addStudent2()" << endl;
Student * s = & n;
mStudents.push_ back(s);
}
void School::addStud ent(Student n ){
cout << "Overload addStudent3()" << endl;
Student * s = & n;
mStudents.push_ back(s);
}

void School::getStud entNames(){
cout << "*** List ***" << endl;
for(int i=0;i < mStudents.size( ); i++)
{
cout << mStudents.at(i)->getId() << " " <<
mStudents.at(i)->getName()<<end l;
}
cout << "*** EOF ***" << endl;
}
#endif

[Ian Collins]

Randy wrote:

Hi,

I am a noob. I am trying to store Student objects pointers, in a
vector, within a School object.
I call a setter function to add the pointer. If I use this method it
works,
Student st = Student("Randy" );
Student * stp = & st;
sc.addStudent(s tp);

My problem is passing a Student to the School function. I have an
overridden function. I try to create a pointer from the passed
Student. I bet that's my problem because it's a copy ?

Why not keep it simple and just use one addStudent member?

>
main.cpp
---------------------------------------------------------------------------------------

#include <cstdlib>
#include <iostream>
#include <vector>

// #include "Templates. h"
// #include "PointersAndRef erence.h"
#include "StudentsAndSch ools.h"
using namespace std;

You don't use anything from std::

int main(int argc, char *argv[])
{
// mypair<intok(10 ,23); // Declare an INT class w/
construction
// ok.printValues( );
// referenceTests( );

School sc;
sc.setNames("Pa rkside");

Student st = Student("Randy" );
Student * stp = & st;
sc.addStudent(s tp);

sc.addStudent(S tudent("Biff")) ;

Student st1 = Student("Bill") ;
Student * stp1 = & st1;
sc.addStudent(s tp1);
sc.getStudentNa mes();

system("PAUSE") ;
return EXIT_SUCCESS;
}

--------------- StudentsAndScho ols.h
-------------------------------------------------------------

#ifndef __StudentsAndSc hools__
#define __StudentsAndSc hools__

Don't use guards with leading double underscores, they are reserved.

>
using namespace std;

Never ever put a using directive in a header! It will apply in any file
that includes the header.

>
class School;

class Student {

private:
static int mLastId;
string mName;
int mId;
School * mSchool;

public:
Student(){
cout << "Student Constructor1" << endl;
}
Student(string n){
cout << "Student Constructor2 " << n << endl;
mName = n;
mId = ++mLastId;
}
void setName(string n);
string getName();
int getId();
};
int Student::mLastI d = 0;

string Student::getNam e(){ return mName; };
int Student::getId( ){ return mId; };

These will have to be declared "inline", or placed in a source file.

class School{

private:
string mName;
vector<Student* mStudents;

public:
School(){
cout << "Schools Constructor 1" << endl;
}
void addStudent(Stud ent* );
void addStudent(Stud ent &); // overloaded
function

Silly comment!

void addStudent(Stud ent);

You don't want this one, it is ambiguous.
--
Ian Collins.

[Salt_Peter]

On Apr 13, 8:37 pm, "Randy" <gast...@sympat ico.cawrote:

Hi,

I am a noob. I am trying to store Student objects pointers, in a
vector, within a School object.

In my opinion, you should be storing Students, not pointers to
Students.

I call a setter function to add the pointer. If I use this method it
works,
Student st = Student("Randy" );
Student * stp = & st;
sc.addStudent(s tp);

My problem is passing a Student to the School function. I have an
overridden function. I try to create a pointer from the passed
Student. I bet that's my problem because it's a copy ?

Its a copy alright, a copy of a pointer actually, unfortuanately -
copying pointers does not copy its pointee. And having a pointer to an
object does not guarentee that the object continues to exist.

This may sound a little strange to you right now but its fundamental
in C++. A dumb pointer is just a dumb pointer.

>
This all came about because I want to have a more succinct method for
doing this, just like the big kids do:
Student st = Student("Randy" );
Student * stp = & st;
sc.addStudent(s tp);

I've read lots but am apperantly missing the point. I am referencing
the C++ Primer.

here's my output too ... 2 Bills ?? ahaha ...

Schools Constructor 1
Student Constructor2 Randy
Overload addStudent1()
Student Constructor2 Biff
Overload addStudent3()

Stop right here. This should be your first clue. Take a look at that
member function:

void School::addStud ent(Student n ){
cout << "Overload addStudent3()" << endl;
Student * s = & n;
mStudents.push_ back(s);
}

You are storing pointers and yet parameter (Student n) ceases to exist
once the above member function terminates. Dumb pointer points to a
Student that is no longer.

The term is: dangling pointer
The result is: undefined behaviour

Student Constructor2 Bill
Overload addStudent1()
*** List ***
1 Randy
3 Bill
3 Bill
*** EOF ***
Press any key to continue . . .

main.cpp
---------------------------------------------------------------------------------------

#include <cstdlib>
#include <iostream>
#include <vector>

// #include "Templates. h"
// #include "PointersAndRef erence.h"
#include "StudentsAndSch ools.h"

using namespace std;

int main(int argc, char *argv[])
{
// mypair<intok(10 ,23); // Declare an INT class w/
construction
// ok.printValues( );
// referenceTests( );

School sc;
sc.setNames("Pa rkside");

Student st = Student("Randy" );
Student * stp = & st;
sc.addStudent(s tp);

sc.addStudent(S tudent("Biff")) ;

Student st1 = Student("Bill") ;
Student * stp1 = & st1;
sc.addStudent(s tp1);

sc.getStudentNa mes();

system("PAUSE") ;
return EXIT_SUCCESS;

}

--------------- StudentsAndScho ols.h
-------------------------------------------------------------

#ifndef __StudentsAndSc hools__
#define __StudentsAndSc hools__

Underscore + Capitale letter is reserved
2 Underscores + whatever is also reserved

#ifndef StudentsAndScho ols_h
#define StudentsAndScho ols_h

Although Student should have its own header and School ditto

>
using namespace std;

Using directives in a header file is a very bad idea.

>
class School;

class Student {

private:
static int mLastId;
string mName;
int mId;
School * mSchool;

public:
Student(){
cout << "Student Constructor1" << endl;
}
Student(string n){
cout << "Student Constructor2 " << n << endl;
mName = n;
mId = ++mLastId;
}

Initialize non-static members using an init list.

Student(std::st ring n) : mName(n), mId(++mLastId)
{
cout << "Student(std::s tring n) " << n << endl;
}

void setName(string n);

void setName(const std::string&);

string getName();

std::string getName() const;

int getId();};

int getId() const;

>
int Student::mLastI d = 0;

string Student::getNam e(){ return mName; };
int Student::getId( ){ return mId; };

class School{

private:
string mName;
vector<Student* mStudents;

public:
School(){
cout << "Schools Constructor 1" << endl;
}
void addStudent(Stud ent* );
void addStudent(Stud ent &); // overloaded
function

// the key is the constant keyword, the only version you need is by
const reference

void add(const Student&);

// the next "overload" prevents the former from being called although
the compiler should be generating a diagnostic about a conflict (which
one of these "overloads" should it call?).

void addStudent(Stud ent);

void setNames(string n);
void getStudentNames ();

const qualifiers missing above

<snip>

[Salt_Peter]

On Apr 13, 11:59 pm, "Salt_Peter " <pj_h...@yahoo. comwrote:

On Apr 13, 8:37 pm, "Randy" <gast...@sympat ico.cawrote:

Hi,

I am a noob. I am trying to store Student objects pointers, in a
vector, within a School object.

In my opinion, you should be storing Students, not pointers to
Students.

Here is an example without pointers. Note the Student's copy ctor and
the effects of uncommenting the std::vector's reserve in the School's
ctor.

#include <iostream>
#include <ostream>
#include <string>
#include <vector>
#include <algorithm>
#include <iterator>

class Student
{
int id;
std::string name;
public:
// ctors
Student() : id(0), name()
{
std::cout << "Student()\ n";
}
Student(int i, std::string n) : id(i), name(n)
{
std::cout << "Student(in t i, std::string n)\n";
}
// copy ctor
Student(const Student& copy)
{
std::cout << "Student(co nst Student& copy)\n";
id = copy.id;
name = copy.name;
}
// friend op
friend std::ostream& operator<<(std: :ostream&, const Student&);
};

std::ostream& operator<<(std: :ostream& os, const Student& r)
{
os << "id: " << r.id;
os << "\tname: " << r.name;
return os << std::endl;
}

class School
{
static int lastid;
std::string name;
std::vector< Student students;
public:
// ctor
School(std::str ing n) : name(n), students()
{
std::cout << "School()\n ";
// students.reserv e(64);
}
// member functions
void add(const std::string& s)
{
students.push_b ack( Student(++lasti d, s) );
}
// friend op
friend std::ostream& operator<<(std: :ostream&, const School&);
};

int School::lastid;

std::ostream& operator<<(std: :ostream& os, const School& r)
{
os << std::string(30, '-');
os << "\nschool: " << r.name;
os << "\nstudents : " << r.lastid;
os << std::endl;
std::copy( r.students.begi n(),
r.students.end( ),
std::ostream_it erator< Student >(os) );
os << std::string(30, '-');
return os << std::endl;
}

int main ()
{
School school("The Academy");
school.add("Alf red A");
school.add("Bet ty B");
school.add("Car l C");

std::cout << school;
}

/*
School()
Student(int i, std::string n)
Student(const Student& copy)
Student(int i, std::string n)
Student(const Student& copy)
Student(const Student& copy)
Student(int i, std::string n)
Student(const Student& copy)
Student(const Student& copy)
Student(const Student& copy)
------------------------------
school: The Academy
students: 3
id: 1 name: Alfred A
id: 2 name: Betty B
id: 3 name: Carl C
------------------------------
*/

[Roland Pibinger]

On 13 Apr 2007 20:59:52 -0700, "Salt_Peter " wrote:

>On Apr 13, 8:37 pm, "Randy" <gast...@sympat ico.cawrote:

>I am trying to store Student objects pointers, in a
vector, within a School object.

In my opinion, you should be storing Students, not pointers to
Students.

Students are a classic objects (in the sense of OOP) which are
characterized by identity, state and behavior. You usually do not
duplicate (copy) and assign objects and therefore make their copy
constructor and assignment operator private. std::vector<Stu dentis
not a viable solution.
--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch

[Randy]

On Apr 14, 4:57 am, rpbg...@yahoo.c om (Roland Pibinger) wrote:

On 13 Apr 2007 20:59:52 -0700, "Salt_Peter " wrote:

On Apr 13, 8:37 pm, "Randy" <gast...@sympat ico.cawrote:

I am trying to store Student objects pointers, in a
vector, within a School object.

In my opinion, you should be storing Students, not pointers to
Students.

Students are a classic objects (in the sense of OOP) which are
characterized by identity, state and behavior. You usually do not
duplicate (copy) and assign objects and therefore make their copy
constructor and assignment operator private. std::vector<Stu dentis
not a viable solution.

--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch

Thank you very much for sharing your time and experience. You more
than answered my questions and now I have some focused learning to do.
Randy

[I V]

On Sat, 14 Apr 2007 08:57:23 +0000, Roland Pibinger wrote:

Students are a classic objects (in the sense of OOP) which are
characterized by identity, state and behavior. You usually do not

Really? I would have thought that Randy's Student class is a classic
_value_. Their identity is defined by equivalence (I don't
think you would want to treat students with the same name, at the same
school, with the same id, as being different), and they don't really have
any behavior (the only methods the class has are accessors). Why do you
think they should be considered entities?

[Salt_Peter]

On Apr 14, 4:57 am, rpbg...@yahoo.c om (Roland Pibinger) wrote:

On 13 Apr 2007 20:59:52 -0700, "Salt_Peter " wrote:

On Apr 13, 8:37 pm, "Randy" <gast...@sympat ico.cawrote:

I am trying to store Student objects pointers, in a
vector, within a School object.

In my opinion, you should be storing Students, not pointers to
Students.

Students are a classic objects (in the sense of OOP) which are
characterized by identity, state and behavior. You usually do not
duplicate (copy) and assign objects and therefore make their copy
constructor and assignment operator private. std::vector<Stu dentis
not a viable solution.

--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch

On what basis is the solution not viable?
Are you suggesting that a Student Record is not usueable elsewhere?
Why should a program or program(s) not have a dataset that is copyable
in order to process it in whatever way it does? What makes you beleive
that a copy implies a duplicate? (its not in the proposed std::vector<
Student solution)
For all we know, that dataset is read and stored to file.

Why further complicate a program by a std::vector< Student* where
the Student's allocation is then given to yet another entity?
(Specially since we are dealing here with an OP that is having issues
with dangling pointers)

[James Kanze]

On Apr 14, 10:57 am, rpbg...@yahoo.c om (Roland Pibinger) wrote:

On 13 Apr 2007 20:59:52 -0700, "Salt_Peter " wrote:

On Apr 13, 8:37 pm, "Randy" <gast...@sympat ico.cawrote:

I am trying to store Student objects pointers, in a
vector, within a School object.

In my opinion, you should be storing Students, not pointers to
Students.

Students are a classic objects (in the sense of OOP) which are
characterized by identity, state and behavior.

I don't think he's given us enough information to draw that
conclusion. It depends on the role and the responsibilitie s of
the class in the actual application. If all the class
represents is a specific identity, it could be given value
semantics. If it has some real behavior, then it's probably an
entity object, and identity becomes important. (And of course,
if identity is important, you block copy and assignment, as you
said.)

--
James Kanze (Gabi Software) email: ja*********@gma il.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Roland Pibinger]

On Sat, 14 Apr 2007 19:24:43 +0000 (UTC), I V <iv*****@gmail. com>
wrote:

>On Sat, 14 Apr 2007 08:57:23 +0000, Roland Pibinger wrote:

>Students are a classic objects (in the sense of OOP) which are
characterize d by identity, state and behavior. You usually do not

Really? I would have thought that Randy's Student class is a classic
_value_. Their identity is defined by equivalence (I don't
think you would want to treat students with the same name, at the same
school, with the same id, as being different), and they don't really have
any behavior (the only methods the class has are accessors). Why do you
think they should be considered entities?

What should the following mean?

Student Ivlenin;
Student Randy = Ivlenin;
--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch