Trying To Implement A 'Player' Class

This is a discussion on Trying To Implement A 'Player' Class within the C++ Programming forums, part of the General Programming Boards category; I'm trying to implement a player class that contains the following attributes: -> Name -> Position Played -> High School ...

  1. #1
    Registered User
    Join Date
    Nov 2002
    Posts
    6

    Trying To Implement A 'Player' Class

    I'm trying to implement a player class that contains the following attributes:

    -> Name
    -> Position Played
    -> High School Graduated From
    -> Height
    -> Scoring Average
    -> Rebounding Average
    -> GPA
    -> Seasons Of Eligibility Remaining

    And the class must have the following functions:

    -> Sort list of objects by name.
    -> Sort list of objects by scoring average.
    -> Get list of objects that contain a GPA of over 3.0.
    -> Sort list of objects by high school graduated from.

    This is what I've come up with so far:

    player.h
    Code:
    // Player Header File (player.h)
    
    #include "apstring.h"
    
    class player
    {
    	public:
    
    	// Constructors
    
    	player();
    	player(apstring name, apstring position, apstring high_school, int height, double average, double rebounding, double gpa, int seasons);
    	player(const player &p);
    
    	// Destructor
    
    	~player();
    
    	// Accessors
    
    	apstring get_name() const;
    	apstring get_position() const;
    	apstring get_high_school() const;
    	int get_height() const;
    	double get_scoring_average() const;
    	double get_rebounding_average() const;
    	double get_gpa() const;
    	int get_seasons() const;
    
    	// Assignment
    
    	const player& operator = (const player &p);
    
    	// Modifiers
    
    	void set_name(apstring name);
    	void set_position(apstring position);
    	void set_high_school(apstring high_school);
    	void set_height(int height);
    	void set_scoring_average(double scoring_average);
    	void set_rebounding_average(double rebounding_average);
    	void set_gpa(double gpa);
    	void set_seasons(int seasons);
    
    	// Other Methods
    
    	void sort_names(player p[ ], int length);
    	void sort_scoring_averages(player p[ ], int length);
    	void sort_gpas(player p[ ], int length);
    	void sort_high_schools(player p[ ], int length);
    	void print(player p[ ], int length);
    
    	private:
    
    	// Private Data
    
    	apstring my_name, my_position, my_high_school;
    	double my_scoring_average, my_rebounding_average, my_gpa;
    	int my_height, my_seasons;
    
    	// Private Methods
    
    	void swap(player &x, player &y);
    };
    player.cpp
    Code:
    // Player Class Implementation (player.cpp)
    
    #include "player.h"
    
    // Constructors
    
    player::player()
    {
    	my_name = "";
    	my_position = "";
    	my_high_school = "";
    	my_height = 0;
    	my_scoring_average = 0.00;
    	my_rebounding_average = 0.00;
    	my_gpa = 0.00;
    	my_seasons = 0;
    }
    
    player::player(apstring name, apstring position, apstring high_school, int height, double scoring_average, double rebounding_average, double gpa, int seasons)
    {
    	my_name = name;
    	my_position = position;
    	my_high_school = high_school;
    	my_height = height;
    	my_scoring_average = scoring_average;
    	my_rebounding_average = rebounding_average;
    	my_gpa = gpa;
    	my_seasons = seasons;
    }
    
    player::player(const player &p)
    {
    	my_name = p.my_name;
    	my_position = p.my_position;
    	my_high_school = p.my_high_school;
    	my_height = p.my_height;
    	my_scoring_average = p.my_scoring_average;
    	my_rebounding_average = p.my_rebounding_average;
    	my_gpa = p.my_gpa;
    	my_seasons = p.my_seasons;
    }
    
    // Destructor
    
    player::~player()
    {
    
    }
    
    // Accessors
    
    apstring player::get_name() const
    {
    	return my_name;
    }
    
    apstring player::get_position() const
    {
    	return my_position;
    }
    
    apstring player::get_high_school() const
    {
    	return my_high_school;
    }
    
    int player::get_height() const
    {
    	return my_height;
    }
    
    double player::get_scoring_average() const
    {
    	return my_scoring_average;
    }
    
    double player::get_rebounding_average() const
    {
    	return my_rebounding_average;
    }
    
    double player::get_gpa() const
    {
    	return my_gpa;
    }
    
    int player::get_seasons() const
    {
    	return my_seasons;
    }
    
    // Assignment
    
    const player& player::operator = (const player &p)
    {
    	if (this != &p)
    	{
    		my_name = p.my_name;
    		my_position = p.my_position;
    		my_high_school = p.my_high_school;
    		my_height = p.my_height;
    		my_scoring_average = p.my_scoring_average;
    		my_rebounding_average = p.my_rebounding_average;
    		my_gpa = p.my_gpa;
    		my_seasons = p.my_seasons;
    	}
    
    	return *this;
    }
    
    // Modifiers
    
    void player::set_name(apstring name)
    {
    	my_name = name;
    }
    
    void player::set_position(apstring position)
    {
    	my_position = position;
    }
    
    void player::set_high_school(apstring high_school)
    {
    	my_high_school = high_school;
    }
    
    void player::set_height(int height)
    {
    	my_height = height;
    }
    
    void player::set_scoring_average(double scoring_average)
    {
    	my_scoring_average = scoring_average;
    }
    
    void player::set_rebounding_average(double rebounding_average)
    {
    	my_rebounding_average = rebounding_average;
    }
    
    void player::set_gpa(double gpa)
    {
    	my_gpa = gpa;
    }
    
    void player::set_seasons(int seasons)
    {
    	my_seasons = seasons;
    }
    
    // Other Methods
    
    void player::sort_names(player a[ ], int length)
    {
    	int min_index = 0;
    	
    	for (int j = 0; j < length - 1; ++j)
    	{
    		for (int k = j + 1; k < length; ++k)
    			if (a[k].get_name() < a[min_index].get_name())
    				min_index = k;
    	}
    
    	swap(a[j], a[min_index]);
    }
    
    void player::sort_scoring_averages(player a[ ], int length)
    {
    	int min_index = 0;
    
    	for (int j = 0; j < length - 1; ++j)
    	{
    		for (int k = j + 1; k < length; ++k)
    			if (a[k].get_scoring_average() < a[min_index].get_scoring_average())
    				min_index = k;
    	}
    
    	swap(a[j], a[min_index]);
    }
    
    void player::sort_gpas(player a[ ], int length)
    {
    	int min_index = 0;
    
    	for (int j = 0; j < length - 1; ++j)
    	{
    		for (int k = j + 1; k < length; ++k)
    			if (a[k].get_gpa() < a[min_index].get_gpa())
    				min_index = k;
    	}
    
    	swap(a[j], a[min_index]);
    }
    
    void player::sort_high_schools(player a[ ], int length)
    {
    	int min_index = 0;
    
    	for (int j = 0; j < length - 1; ++j)
    	{
    		for (int k = j + 1; k < length; ++k)
    			if (a[k].get_high_school() < a[min_index].get_high_school())
    				min_index = k;
    	}
    
    	swap(a[j], a[min_index]);
    }
    
    void player::print(player a[ ], int length)
    {
    	cout << "Name / Position Played / High School Graduated From / Height / Scoring Average / Rebounding Average / GPA / Seasons Of Eligibility Remaining" << endl;
    
    	for (int j = 0; j < length; ++j)
    		cout << a[j].get_name() << " " << a[j].get_position() << " " << a[j].get_high_school() << " " << a[j].get_height() << " " << a[j].get_scoring_average() << " " << a[j].get_rebounding_average() << " " << a[j].get_gpa() << " " << a[j].get_seasons() << endl;
    }
    
    // Private Methods
    
    void player::swap(player &x, player &y)
    {
    	player temp = x;
    	x = y;
    	y = temp;
    }
    basketball_players.cpp
    Code:
    #include <iostream.h>
    #include <fstream.h>
    #include "player.h"
    
    void main()
    {
    	// Declarations
    
    	apstring file, line, name, position, high_school;
    	double scoring_average, rebounding_average, gpa;
    	ifstream in_file;
    	int counter = 0, num_players = 0, height, seasons;
    	player *b_player;
    
    	// Get file name.
    
    	cout << "Enter file name." << endl;
    	cin >> file;
    
    	// Get number of players.
    
    	cout << "Enter number of players." << endl;
    	cin >> num_players;
    
    	// Create dynamic array for players.
    
    	b_player = new player[num_players];
    
    	// Open file.
    
    	in_file.open(file.c_str());
    
    	// Prime in_file.
    
    	in_file >> name;
    
    	// Assemble each set of data into an object (inside an array of objects).
    
    	while (! in_file.eof())
    	{
    		in_file >> position >> high_school >> height >> scoring_average >> rebounding_average >> gpa >> seasons;
    
    		b_player[counter].set_name(name);
    		b_player[counter].set_position(position);
    		b_player[counter].set_high_school(high_school);
    		b_player[counter].set_height(height);
    		b_player[counter].set_scoring_average(scoring_average);
    		b_player[counter].set_rebounding_average(rebounding_average);
    		b_player[counter].set_gpa(gpa);
    		b_player[counter].set_seasons(seasons);
    
    		in_file >> name;
    
    		++counter;
    	}
    
    	// Close file.
    
    	in_file.close();
    
    	// Sort by name and print.
    
    	cout << "Sorted By Name" << endl;
    	b_player->sort_names(b_player, num_players);
    	b_player->print(b_player, num_players);
    
    	cout << endl;
    
    	// Sort by scoring average and print.
    
    	cout << "Sorted By Scoring Averages" << endl;
    	b_player->sort_scoring_averages(b_player, num_players);
    	b_player->print(b_player, num_players);
    
    	cout << endl;
    
    	// Print all players who have a GPA of 3.0 or higher.
    
    	cout << "All Players With GPA Of 3.0 Or Higher" << endl;
    	b_player->sort_gpas(b_player, num_players);
    	b_player->print(b_player, num_players);
    
    	cout << endl;
    
    	// Sort by high school and print.
    
    	cout << "Sorted By High School" << endl;
    	b_player->sort_high_schools(b_player, num_players);
    	b_player->print(b_player, num_players);
    }
    What the basketball_players.cpp file does is read a list of players and their information from a file and convert each line of information into a player object. For some reason the sort methods (like sort_names, sort_scoring_averages, sort_gpas, and sort_high_schools methods) are not working the way they should. When the lists are printed out, the lists are the same each time.

    I know this post was long, but I hope somebody can figure out why those methods are not being done correctly.

    I greatly appreciate any help.

  2. #2
    Registered User Codeplug's Avatar
    Join Date
    Mar 2003
    Posts
    4,699
    Do you know how to use a debugger? If not, now is a great time to learn. If you want to be a programmer, you're gonna have to learn it anyway - might as well be now.

    What development tools are you using?

    In any case, if you want someone to debug your code for you, you should zip up all your source files along with a sample input file and post it along with steps to reproduce a specific problem that you can not solve or find in the code.

    gg

  3. #3
    Senior Member joshdick's Avatar
    Join Date
    Nov 2002
    Location
    Phildelphia, PA
    Posts
    1,146
    You have one major design flaw in your class. Your class is player, singular. An instance of player is just one player. Therefore, you can't have sort functions in your player class, becuase you can't sort a single player. Here's what you need to do. Cut all of those sort functions out of your player class, and you'll have a decent class that well represents a player. Then you need to decide which container would best represent a list of players. A vector would probably suffice. Then, write some functions to sort a vector full of players.

    Another suggestion I'd have is to get to know a little bit about the algorithm library. That library contains a boatload of template functions to do things like swap, search, and sort. You could probably save yourself from reinventing the wheel if you used the standard library more.
    FAQ

    "The computer programmer is a creator of universes for which he alone is responsible. Universes of virtually unlimited complexity can be created in the form of computer programs." -- Joseph Weizenbaum.

    "If you cannot grok the overall structure of a program while taking a shower, you are not ready to code it." -- Richard Pattis.

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Class design problem
    By h3ro in forum C++ Programming
    Replies: 10
    Last Post: 12-19-2008, 09:10 AM
  2. player class
    By lilhawk2892 in forum C++ Programming
    Replies: 14
    Last Post: 08-30-2006, 08:05 AM
  3. Replies: 3
    Last Post: 10-31-2005, 12:05 PM
  4. structure vs class
    By sana in forum C++ Programming
    Replies: 13
    Last Post: 12-02-2002, 07:18 AM
  5. Abstract class problem
    By VanJay011379 in forum C++ Programming
    Replies: 9
    Last Post: 07-31-2002, 02:30 PM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21