problem with class

hey,
I'm making a crappy little rpg text game. Anyway I set it up so that the player stats are all saved into a class. I have a function which creates the class when a new game is started. The problem is that I can only access the class functions through the function which I used to create it.

Code:

---

#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string>
#include <stdlib.h>
#include <time.h>
#include <string>
class character{
public:
int health;
int strength;
int armor;
string name;

character(int, int, int, string);
~character();
void viewStats();
string saveStats();
};

character::character(int h, int s, int a, string n){
health = h;
strength = s;
armor = a;
name = n;
}
character::~character(){
}
void character::viewStats(){
cout << "\n";
cout << "Name: " << name << endl;
cout << "Health: " << health << endl;
cout << "Strength: " << strength << endl;
cout << "Armor: " << armor << endl;
}
string character::saveStats(){
string send;
send += name + "#";
send += health + "#";
send += strength + "#";
send += armor + "#";
return send;
}


int GetRand(int min, int max)
{
  static int Init = 0;
  int rc;
  if (Init == 0)
  {
    srand(time(NULL));
    Init = 1;
  }
  rc = (rand() % (max - min + 1) + min);
 
  return (rc);
}
void newGame(){
string temp;
int a, b, c;
cout << "\nName:";
cin.get();
getline(cin, temp, '\n');
again:
a = GetRand(10, 15);
b = GetRand(10, 15);
c = GetRand(50, 70);
character player(c, a, b, temp);
player.viewStats();
cout << "\n\nNew Stats (Y\\N)\n\n";
char choice;
cin >> choice;
if(choice == 'y' || choice == 'Y'){
goto again;
}

}

void clear(){
for (int i =0; i < 25; i++){
cout << "\n";
}
}
void sort(string command){
int which;
which = command.find("\\help", 0);
if(which == 0){
cout << "Help menu!";
return;
}
which = command.find("\\save", 0);
if(which == 0){
cout << player.saveStats();
}
}

int main(int argc, char *argv[])
{
int choose;
string command;
cout << "Menu:\n\n1.New Game\n2.Load\n3.Quit\n\n";
cin >> choose;
switch (choose)
{
case 1:
newGame();
break;
}
clear();
cout << "Welcome to this crappy RPG game. To see the commands type \\? or \\help\n\n";
cout << "It\'s recommended that you save. You can save at any time by typing \\save\n\n";
cin.get();
getline(cin, command, '\n');
sort(command);
cin >> choose;
  return 0;
}

---

I realize this code is probably written very poorly. Anyway, the function that you should worry about is newGame();

Any help would be apreciated thanks

One way is to make a Game class that keeps the character as a member (or a container of characters as a member). Then all the game related function could be members of the Game class and can use the member variable that holds the character.

Another way is to pass a reference or pointer to the new character around. If you did this you would have to dynamically allocate (with new) the character you create in newGame() and remember to delete it later, which is dangerous. Or you could create the character in main and then pass it by reference to the other functions.

I like the first solution better.

thanks

Umm, I dont have a problem with it, but some people really get worked up when you use goto's

So if it worries you, why not do something like:

Code:

---

int busy=1;
char choice;
int main(){
while (busy==1){
//game code goes here
if (choice=="n"){
busy=0;
break;
}
}
}

---

Hope it helps ;)

yea, I've heard that about gotos
why is that?

Because sometimes it creates "sphaggetti code" where its all mixed up and hard to tell where to go to next.

Speaking of code thats hard to read...indent please, it will help yourself and people viewing your code.

Goto is also unnecessary in almost every situation in C++, there are however 1/10000 situations where it might be more clear to use a goto.

Its also said that sometimes a goto could result in unpredictable results.

www.cprogramming.com/tutorial/goto.html

http://www.gmonline.demon.co.uk/cscene/CS7/CS7-02.html // example where it could be the "best choice to use it".

Hi there, I'm new. :)

I search the c++ forum for "class", pick the first topic, and what do I find?
Someone with the exact same problem I am having!

I am writing a texst/rpg-type game, and I would like a funktion to be able to access the public variables of an object.

Now, I think Daved said that it could be done, by passing a refference to the object, that had to be deleted later, and is dangerous.
Ehh, how dangerous is it? And What could it possibly do?

Is there perhaps a safer way, to only let funktions access the public methods of the object? Or would that need the dreaded refference too? ;)

Thank you in advance!

Well for starters, you're both doing it poorly. Your data doesn't need to be public, you just need public access to it. Consider:

Code:

---

class Foo
{
    private:
        int bar;

    public:
        void setBar( int baz ) { bar = baz; }
        int getBar( void ) { return bar; }
};

---

Quzah.

using quzah's class, you can do it this way:

Code:

---

#include<iostream>

class Foo
{
        private:
                int bar;
        public:
                void setBar( int baz ) { bar = baz; }
                int getBar( void ) { return bar; }
};

void changeFoosBar(int changeTo,Foo*target);

int main()
{
                Foo *fooClass=new Foo();
                fooClass->setBar(0);
                changeFoosBar(20,fooClass);
                std::cout<<fooClass->getBar()<<std::endl;
                delete fooClass;
                return 0;
}

void changeFoosBar(int changeTo,Foo*target)
{
        target->setBar(changeTo);
}

---

or if you really want to access them directly (which I highly recommend you don't do), you can just pass them in by reference:

Code:

---

#include<iostream>

class Foo
{
        public:
                int bar;
};

void changeFoosBar(int changeTo,int&changeThis);

int main()
{
                Foo fooClass;
                fooClass.bar=0;
                changeFoosBar(20,fooClass.bar);
                std::cout<<fooClass.bar<<std::endl;

                return 0;
}

void changeFoosBar(int changeTo,int&changeThis)
{
        changeThis=changeTo;
}

---

Why did you use dynamic allocation for the first one major instead of passing the class by reference?

Quote:

---

Originally Posted by prog-bman

Why did you use dynamic allocation for the first one major instead of passing the class by reference?

---

just because. :D

Nerd. ;)

if it bothers you that much (and because it'd probably be easier for the OP):

Code:

---

#include<iostream>

class Foo
{
        private:
                int bar;
        public:
                void setBar( int baz ) { bar = baz; }
                int getBar( void ) { return bar; }
};

void changeFoosBar(int changeTo,Foo &target);

int main()
{
        Foo fooClass;
        fooClass.setBar(0);
        changeFoosBar(20,fooClass);
        std::cout<<fooClass.getBar()<<std::endl;
        return 0;
}

void changeFoosBar(int changeTo,Foo &target)
{
        target.setBar(changeTo);
}

---

OK, kewl. So that is how it is done.
Then I hear that they have to be destroyed again, or the undefined "danger" will arrise...
Does that mean the pointer/refference itself or the entire object?
And how is it done?

Oh, and thanks again! :)

edit/ Eh, I know how to destroy an object, but if its the refference, I'd still like a shot demonstration...

see my second example... the danger is called a memory leak - if you run the program enough times, theoretically your system would run out of memory. in the learning stages it's not a big danger, but imagine in a company that keeps the program running all day long...

basically, just remember that for every new, you need a correspoding delete, and for every new[], you need a delete[]

Thanks alot Major! :)

Yup, I know about memory leaks... So this is how they happen? Didn't Windows have some? ;)

Couldn't you just destroy all pointers in the end of the funktion that uses them, thereby eliminating the problem?

btw, I don't see new, nor new[] anywhere in your example using refference. I suppose they still have to be destroyed somehow?

I'm sorry. that was my first example they were in...

you could, except in the case where you're constantly creating new ones... for example, take this code for a linked list. you'll notice that new and delete actually occur in loops:

Code:

---

#include<iostream>      //for console I/O
#include<string>        //for string class

struct node;            //prototyped for linking in itself

struct node            //structure
{
        std::string data;      //to hold the data
        node*link;              //a pointer to the next one in the list
};

int main()
{
        std::string line;      //to hold input

        node*head=new node;    //this pointer holds the head of the list
        node*curr=head;        //this is where the work is done
        node*next=head;        //this is to help move down the list
        curr->link=0;          //set the pointer to null to avoid problems

        std::cout<<"Enter some lines of text:\n\n";

        for(;;)        //semi-infinite loop
        {
                getline(std::cin,line,'\n');    //get input

                if(line=="")    //if there's no input
                {
                        curr->data=line;        //put that in the last one
                        break;  //break out of the loop
                }

                curr->data=line;        //else, put the data in the structure
                next=new node;          //create a new structure in memory
                curr->link=next;        //make the pointer point to it
                curr=next;              //move into it
                curr->link=0;          //and make that pointer null
        }

        curr=head;                      //go to the top of the list
        std::cout<<"You Entered:\n\n";

        while(curr->data!="")          //while there's data
        {
                std::cout<<"> "<<curr->data<<std::endl; //output it
                next=curr->link;        //save the location of the next one
                curr->link=0;          //nullify this link
                delete curr;            //delete this one
                curr=next;              //move into the next one
        }
        delete curr;    //delete the last one (with no data in it)

        return 0;
}

---

If you only have one class for all the data, why not just declare your object outside of everything, so you will not have to pass reference to the class. Why would you need to pass a reference to it, its not like there are going to be 1-5 players, or 1-1000000 in the case of Warcraft. I dont believe this has any negative effects, but if it does, you could pass the reference, which I'll show in the next post a different version of this.

Code:

---

#include <iostream>

using namespace std;

typedef unsigned short int USHORT; //makes your own variable, USHORT, which is an unsigned short int

class Player_Stats
{
private:
  USHORT itsLevel;

public:
  Player_Stats():itsLevel(0) {} //constructor, initializing itsLevel variable to 0

  USHORT GetLevel() const { return itsLevel; }
  void SetLevel(USHORT level) { itsLevel = level; }

};

Player_Stats pStats;

void aFunction() {
  cout << pStats.GetLevel() << endl; //output: 0
  pStats.SetLevel(10);
  cout << pStats.GetLevel() << endl; //output: 10
}

int main()
{
  aFunction();

}

---

Like said above, you make your variables in the class private, and make functions to return/set them if necessary in the public, this is if you plan on using them outside that class. You could always do most of your game using all classes, functions of the class, derived from the class, friend of the class, etc. as mentioned above.

generally you should try not to create things globally... if you really wanted to, however, you could also do this:

Code:

---

class Player_Stats
{
  private:
    USHORT itsLevel;

  public:
    Player_Stats():itsLevel(0) {} //constructor, initializing itsLevel variable to 0

    USHORT GetLevel() const { return itsLevel; }
    void SetLevel(USHORT level) { itsLevel = level; }

} pStats;

---

also, I just noticed that your class was missing a semi-colon.

Passing a reference OF the object of the stats class:

Code:

---

#include <iostream>

using namespace std;

typedef unsigned short int USHORT; //makes your own variable, USHORT, which is an unsigned short int

class Player_Stats
{
private:
  USHORT itsLevel;

public:
  Player_Stats():itsLevel(0) {} //constructor, initializing itsLevel variable to 0

  USHORT GetLevel() const { return itsLevel; }
  void SetLevel(USHORT level) { itsLevel = level; }

};

void aFunction(Player_Stats& pStatsCopy) /* argument takes the memory location to an object of Player_Stats class */
{
  cout << pStatsCopy.GetLevel() << endl; //output: 0
  pStatsCopy.SetLevel(10);
  cout << pStatsCopy.GetLevel() << endl; //output: 10
}

int main()
{
  Player_Stats pStats;

  aFunction(pStats);

  cin.get();
}

---

Quote:

---

Originally Posted by major_small

generally you should try not to create things globally... if you really wanted to, however, you could also do this:

Code:

---

class Player_Stats
{
  private:
    USHORT itsLevel;

  public:
    Player_Stats():itsLevel(0) {} //constructor, initializing itsLevel variable to 0

    USHORT GetLevel() const { return itsLevel; }
    void SetLevel(USHORT level) { itsLevel = level; }

} pStats;

---

also, I just noticed that your class was missing a semi-colon.

---

Declaring Class Player_Stats { } pStats; is exactly the same thing as declaring it later (its global either way), its only seperated I think.

Yeah I just noticed that semi-colon too, and was about to edit when I saw this post.

nono I know it's still global, I was just pointing it out to you in case you didn't know you could do it that way.

Quote:

---

Originally Posted by muggizuggi

Hi there, I'm new. :)

I search the c++ forum for "class", pick the first topic, and what do I find?
Someone with the exact same problem I am having!

I am writing a texst/rpg-type game, and I would like a funktion to be able to access the public variables of an object.

Now, I think Daved said that it could be done, by passing a refference to the object, that had to be deleted later, and is dangerous.
Ehh, how dangerous is it? And What could it possibly do?

Is there perhaps a safer way, to only let funktions access the public methods of the object? Or would that need the dreaded refference too? ;)

Thank you in advance!

---

i like this kid he uses search! :D

Ok Major, I slept on it and I think I see your point.
Doing it like that (creating and deleting pointers/references all the time) can get messy, and may also take its toll on the CPU, once I get to more advanced stuff? Or is that not how things work?

And Dae, thanks for trying to help out!
That was exactly what I wanted when I came here, but since it seems to be considered bad practice, maybe I should try an other route?

My original plan was to have one class called "human", and then create an object of that for each character in the game, including the player.

So what if I made the "human" class, and then a "player" sub class to extend the "human" class. Then I could keep all the things that could happen with the player as methods of that class.

Would that be the clever, expandable, reusable OOP way of the wise?

well, you'll need references and pointers, and in this case you kinda have to use them (unless you want to use Dae's approach), but some ways are just easier than others. like in my case, neither are really much 'better' than any other (even though that's debatable), some are just easier on the brain to think about.

and about the player and human subclass, you should look into inheritance. that's exactly what you want there. basically, you could create a human class, and a derived player class that, like you mentioned, extends the human base class. the player class would have all or most of the methods from the human class, plus some of it's own.

Quote:

---

Originally Posted by muggizuggi

And Dae, thanks for trying to help out!
That was exactly what I wanted when I came here, but since it seems to be considered bad practice, maybe I should try an other route?

Would that be the clever, expandable, reusable OOP way of the wise?

---

It isnt bad practice, in this case. The fact that your entire game revolves around your Player makes pure sense that you would create your Player class object globally. Using either method will not result in extra memory used or problems, but makes the code read differently.

However, even though I suggested that.. I agree with Major, I would use references (or pointers) just because it makes the code easier to read, so anyone reading it knows where things are coming from. I believe the reason I even recall using that method is because I did win32 API programming when I didnt know how to work with multiple files, OOP, or inheritance well enough that I had global objects and used 'externs'.