You are right, In the book, they should be private. But that shouldn't make a difference as the source.cpp doesn't call any of that. I agree that's a bad practice though.jtbell said:
I am working on that also. I am still checking my c-string stuffs, I have to go back to my notes, have not work on c-string for a while. Got into habit of using std::string whenever called for...Just when I feel comfortable!I want to emphasize, the name of the project that has problem is called 13.2. It has been giving me problem as of yesterday when I still using std::strings. I have worked on it, copy over to the temp project and another one. Those ALWAYS worked. project 13.2 consistently failed. I just did one more time putting those variables pointed out by jtbell, ran again in both 13.2 and temp, 13.2 failed and temp works just fine. This is really strange.Jarvis323 said:
I think for Inventory item, it might make sense to have a fixed size C-string so that you can use your binary IO in a straightforward way, and have guarantees on the storage requirements. I don't think performance or memory is a concern here. You can still use string while storing just a char array in InvItem if you want to. You could write something like this.yungman said:
#ifndef InvItem_H
#define InvItem_H
#include <cstring>
#include <string>
class invItem
{
private:
static const int DESC_SIZE = 21;
char m_description[ DESC_SIZE ]; // m_ prefix reminds you this is a member variable
double m_cost;
int m_units;
public:
invItem()
{
m_description[ 0 ] = '\0';
m_cost = 0.0;
m_units = 0;
}
invItem(
const std::string & d,
double c,
int u )
{
setDesc( d );
setCost( c );
setUnits( u );
}
//Mutator function
void setDesc(const std::string & d)
{
std::snprintf(
m_description,
DESC_SIZE,
"%s",
d.c_str() );
}
void setCost(double c) { m_cost = c; }
void setUnits(int u) { m_units = u; }
//Accessor functions
std::string getDesc() const { return std::string( m_description ); }
double getCost() const { return m_cost; }
int getUnits() const { return m_units; }
};
#endif#include "invItem.h"
#include <iostream>
#include <iomanip>
int main()
{
invItem item1( "Hammer", 6.95, 12 );
cout << left << setw(30) << " Item description: " << item1.getDesc() << "\n";
cout << left << setw(30) << " Cost: " << "$" << item1.getCost() << "\n";
cout << left << setw(30) << " Units on hand: " << item1.getUnits() << "\n\n";
return 0;
}#ifndef InvItem_H
#define InvItem_H
#include <cstring>
#include <string>
class invItem
{
private:
string m_description;
double m_cost;
int m_units;
public:
invItem()
{
m_description.reserve( 20 );
m_cost = 0.0;
m_units = 0;
}
invItem(
const std::string & d,
double c,
int u )
{
setDesc( d );
setCost( c );
setUnits( u );
}
//Mutator function
void setDesc(const std::string & d)
{
m_description = d;
m_description.shrink_to_fit();
}
void setCost(double c) { m_cost = c; }
void setUnits(int u) { m_units = u; }
//Accessor functions
const std::string & getDesc() const { m_description; }
double getCost() const { return m_cost; }
int getUnits() const { return m_units; }
};
#endif#ifndef InvItem_H
#define InvItem_H
#include <cstring>
#include <string>
class invItem
{
private:
char * m_description;
double m_cost;
int m_units;
public:
// make sure memory allocated for m_description is freed when the object is destroyed
~invItem()
{
delete m_description;
}
invItem()
{
m_description = nullptr;
m_cost = 0.0;
m_units = 0;
}
invItem(
const std::string & d,
double c,
int u )
{
m_description = nullptr;
setDesc( d );
setCost( c );
setUnits( u );
}
//Mutator function
void setDesc(const std::string & d)
{
if( m_description != nullptr )
{
delete m_description;
}
const size_t NEW_SIZE = d.length() + 1;
m_description = new char[ NEW_SIZE ];
std::snprintf(
m_description,
NEW_SIZE,
"%s",
d.c_str() );
}
void setCost(double c) { m_cost = c; }
void setUnits(int u) { m_units = u; }
//Accessor functions
char * getDesc() const { return m_description; }
double getCost() const { return m_cost; }
int getUnits() const { return m_units; }
};
#endifHi JarvisJarvis323 said:
C++ allows a const to be in a header file without causing duplicate symbols but not a variable. Also, every InvItem can share the same DEFAULT_SIZE but not the same description. It's still not great to put the const outside the class in this case though because DEFAULT_SIZE isn't needed outside of the class.yungman said:
Jarvis323 said:
Yes, I am not in position to say which way is better. But, it's time for me to sweat it out a little. Believe me, I am sweating it out right now because the pointer for c-string and std::string is very different as the name of c-string is actually the starting address, and passing c-string in parameter is the address already. Also strlen() and all are different. Particular strncpy_s()....jtbell said:
Did you read my question? Why the same code won't work in one project consistently, but the EXACT code COPIED over to a new temp project AND another existing project compile and ran? Exact same two files copied into 3 projects, two works, one doesn't.Vanadium 50 said:
yungman said:
This is the code I got from the CD with the book and I want to show what doesn't work. It's in the source.cpp fileJarvis323 said:
// This program demonstrates a class with overloaded constructors.
#include <iostream>
#include <iomanip>
#include "InventoryItem.h"
using namespace std;
int main()
{
// Create an InventoryItem object and call
// the default constructor.
InventoryItem item1;
char cAr1[] = "Hammer";//New line to fix problem
// item1.getDescription("Hammer");// Set the description
item1.setDescription(cAr1); //This line works
item1.setCost(6.95); // Set the cost
item1.setUnits(12); // Set the units
// Create an InventoryItem object and call
// constructor #2.
char cAr2[] = "Pliers";//added
//InventoryItem item2("Pliers");
InventoryItem item2(cAr2); //This line works
// Create an InventoryItem object and call
// constructor #3.
char cAr3[] = "Wrench";
//InventoryItem item3("Wrench", 8.75, 20);
InventoryItem item3(cAr3, 8.75, 20);
cout << "The following items are in inventory:\n";
cout << setprecision(2) << fixed << showpoint;
// Display the data for item 1.
cout << "Description: " << item1.getDescription() << endl;
cout << "Cost: $" << item1.getCost() << endl;
cout << "Units on Hand: " << item1.getUnits() << endl << endl;
// Display the data for item 2.
cout << "Description: " << item2.getDescription() << endl;
cout << "Cost: $" << item2.getCost() << endl;
cout << "Units on Hand: " << item2.getUnits() << endl << endl;
// Display the data for item 3.
cout << "Description: " << item3.getDescription() << endl;
cout << "Cost: $" << item3.getCost() << endl;
cout << "Units on Hand: " << item3.getUnits() << endl;
return 0;
}// This class has overloaded constructors.
#ifndef INVENTORYITEM_H
#define INVENTORYITEM_H
#include <cstring> // Needed for strlen and strcpy
// Constant for the description's default size
const int DEFAULT_SIZE = 51;
class InventoryItem
{
private:
char *description; // The item description
double cost; // The item cost
int units; // Number of units on hand
public:
// Constructor #1
InventoryItem()
{ // Allocate the default amount of memory for description.
description = new char [DEFAULT_SIZE];
// Store a null terminator in the first character.
*description = '\0';
// Initialize cost and units.
cost = 0.0;
units = 0; }
// Constructor #2
InventoryItem(char *desc)
{ // Allocate just enough memory for the description.
description = new char [strlen(desc) + 1];
// Copy the description to the allocated memory.
strncpy_s(description, strlen(desc) + 1,desc, strlen(desc) + 1);
// Initialize cost and units.
cost = 0.0;
units = 0; }
// Constructor #3
InventoryItem(char *desc, double c, int u)
{ // Allocate just enough memory for the description.
description = new char [strlen(desc) + 1];
// Copy the description to the allocated memory.
strncpy_s(description, strlen(desc) + 1, desc, strlen(desc) + 1);
// Assign values to cost and units.
cost = c;
units = u; }
// Destructor
~InventoryItem()
{ delete [] description; }
// Mutator functions
void setDescription(char *d)
{ strncpy_s(description, 10, d, 10);}
void setCost(double c)
{ cost = c; }
void setUnits(int u)
{ units = u; }
// Accessor functions
const char *getDescription() const
{ return description; }
double getCost() const
{ return cost; }
int getUnits() const
{ return units; }
};
#endifBut you were calling me out in a sarcastic way. I use the CD from the complete edition of the same book and it has the codes like I just posted to Jarvis. I did have to fix the code to make it work. Now I am going to copy this code into the problem project to see.Vanadium 50 said:
You made one mistakes copying the code from the book. On line 13, item1.getDescription("Hammer"); should be item1.setDescription("Hammer");yungman said:
Ha! The book is wrong, I did not type this from reading the book, I actually copied the code from the CD and ran. I did not even see they were get instead of set!Jarvis323 said:
It probably wasn't wrong when it was made. It's outdated.yungman said:
F5 is used to Continue executing the program. If you didn't have breakpoints, pressing F5 would cause all program lines to execute, either to the end or to some line asking for input.yungman said:
Here's a better way to use VS.yungman said:
InventoryItem item1;It's not clear what you're saying here about three segments of memory. Memory segments are usually divided into stack, heap, and static memory. Each InventoryItem object that you create has its own chunk of memory on the heap, that will contain the item description. You have three overloaded constructors: a default constructor with no parameters, a constructor with just a description parameter, and a constructor with all three parameters.yungman said:
F11 will step into the function one step. F10 will step over the function call and go to the line right after the call to the function. If you know that a function is working correctly it makes more sense to step over (F10) the function call, but if you're debugging the function you want to step into it (F11).yungman said:
Yes, it's good practice to have multiple constructors, and you haven't even come to a couple more -- copy constructor and move constructor.yungman said:
class InventoryItem
{
private:
char *m_description; // The item description
double m_cost; // The item cost
int m_units; // Number of units on hand
public:
.
.
.// Constructor #2
InventoryItem(char *description)
{ // Allocate just enough memory for the description.
m_description = new char[strlen(description) + 1];
// Copy the description to the allocated memory.
strncpy_s(m_description, strlen(description) + 1, description, strlen(description) + 1);
// Initialize cost and units.
m_cost = 0.0;
m_units = 0;
}// Constructor #3
InventoryItem(char *description, double cost, int units)
{ // Allocate just enough memory for the description.
m_description = new char[strlen(description) + 1];
// Copy the description to the allocated memory.
strncpy_s(m_description, strlen(description) + 1, description, strlen(description) + 1);
// Assign values to cost and units.
m_cost = cost;
m_units = units;
}This is a bad idea to use all those variants with numbers at the end. In the examples I show above, if two constructors do something with the same class data member, the parameter names can be, and should be, the same.yungman said:
Mark44 said:
yungman said:
No, the program is done with Constructor #1. That's what happened in the lineyungman said:
InvItem item1;I see, it's private, so the moment it leaves Constructor#1, I cannot see it anymore.Mark44 said:
Thanks for reminding me. I read and even put in my notes Class is the blueprint only. But when dealing with codes, it quickly becomes just an external function...like a function call to a function outside of the project.Jarvis323 said:
So invItem is a Class, the blue print of allocating memory using description and two variables cost and units. It is a blue print until the program say invItem item1 than item1 is the object being created. I see now invItem Class is NOT the blueprint of the program, just one of the structure like item1, 2 or 3.Jarvis323 said:
struct invItem
{
char* desc = new char[L];
double cost;
int unit;
}In the Debug menu, there is Step Backward, or Alt [.yungman said:
It's the same idea for a struct. The struct definition is the template for how a struct instance is laid out in memory.yungman said:
That's the wrong way to think about things. Instead of thinking about the files where the functions are defined, the member functions of a struct are internal to the class. Whether the function definitions appear in the header file or in another .cpp file is really irrelevant.yungman said:
The header file isn't the class blueprint -- the class definition, class InvItem, in this case -- is the blueprint, or template.yungman said:
It's different because this struct doesn't have any member functions. It's also different in that the three data members are public.yungman said:
In C++, the only difference between a struct and a class is that members of a struct are public, by default. That's the only difference. A struct can have member functions, just like a class.yungman said:
Thanks for the reply.Mark44 said:
No, it is a blueprint just like a class is. See page 592 of your book, where Gaddis introduces structures by defining a struct data type named PayRoll.yungman said:
struct PayRoll
{
int empNumber; // Employee number
char name[SIZE]; // Employee's name
double hours; // Hours worked
double payRate; // Hourly pay rate
double grossPay; // Gross pay
};After that that statement, there now exist "sub-variables" named deptHead.empNumber, deptHead.name, etc.Gaddis said:
The debugger has to be running for this option to appear.yungman said:
Yes, if cost were listed among the public members of the class, you could access it directly from an object using the dot operator. This is not a good idea, as it defeats one of the major attributes of OO design, encapsulation -- a class should provide a set of accessors and mutators to limit access to the data members of a class.yungman said:
Yes, I was running debug by hitting F5 first and stop at the break point before I check. This is the picture. I don't see it.Mark44 said:
Thank you for the explanation. I am getting this.jtbell said: