Hello once again everyone, my previous problem appears to be resolved right now thanks for everyone who has helped.
I have to make the following derived class
Your LField class is derived from your Field class and represents a line field.
Upon instantiation, an LField object receives between three and five values, in the following order:
* required:
o an int holding the row number on which the line field is positioned,
o an int holding the column number at which the line field begins,
o an int holding the width of the line field,
* optional:
o a char string holding the initial value of the line field, and
o a bool holding the editability flag for the line field: true for editable, false for not editable.Your design does not impose any limit on the width of the line field.
If the calling function specifies the first three parameters only, your LField object holds an empty string and is editable. If the calling function specifies the first four parameters only, your object is editable.
If the calling function specifies invalid coordinates, your object uses the closest on-screen coordinates to those specified. If the width is too long for the line field to fit on a screen, your object reduces the width so that the contracted field does fit on the screen. If the initial value occupies more than the field width, your object uses only as many characters of the initial value as will fit within the specified, and if necessary, contracted width.
Your LField class has the following public member functions:
* void display() - causes the line field to be displayed. On systems where terminal output is buffered, your function does not flush the screen buffer. If the field's current value is shorter than the field width, your function fills the right end of the field with trailing spaces. (Such trailing spaces are however not part of the data of the field itself).
* int edit() displays the line field and then, if the field is editable, lets the user edit the field. Your function returns the key code used to terminate editing. The first time a caller calls your function, it positions the cursor at the beginning of the field. Every subsequent time that the caller calls your function, it initially positions the cursor where it was at the end of the previous call, unless the string is now too small, in which case your function positions the cursor just past the end of the string.
Where the field is not editable, your function returns 0 without waiting for any user input.
* bool editable() const returns true if the field is editable, false if it is display-only.
* void *data() returns the address of the string currently stored by the field. In classes derived from LField, this address may be the address of some other type of data being edited.
* Field *clone() const dynamically allocates a separate instance of an LField, making the new instance a copy of the current LField object, and returns the address of the copy. If your function cannot allocate space for a separate instance, your function returns NULL.
It is the calling function's responsibility to deallocate the memory allocated for this copy.
(This function enables the calling function to make a copy of an instance of a class derived from LField without limiting the copy to being a duplicate of the base class object.)Since your LField class requires dynamic memory allocation to admit field widths without limitation, your class includes a copy constructor, an assignment operator and a virtual destructor.
I apologize for the lengthy text above I just want to show what it is that I have to do exactly.
This is what I have for my header file:
class LField : public Field{
int row_loc, col_loc, width_tot, index;
char *initval;
bool edib;
public:
LField(int row, int col, int width);
LField(int row, int col, int width, char *s);
LField(int row, int col, int width, char *s, bool editable);
void initialize(int r, int c, int w, bool e);
~LField();
void display();
int edit();
bool editable() const;
void *data();
Field *clone() const;
LField& operator = (const LField & rhs);
LField(const LField & source );
}and this is what I have in my cpp file:
LField::LField(int row, int col, int width){
//Checks for valid coords
if(row < 0){
row = 0;
}
if(row > dtioRows()){
row = dtioRows() - 1;
}
if(col < 0){
col = 0;
}
if(col > dtioColumns()){
col = dtioColumns() - 1;
}
//Checks for width and location
if((col + width) > dtioColumns()){
width = width - ((col + width) - dtioColumns());
}
initialize(row, col, width, true);
initval = NULL;
}
LField::LField(int row, int col, int width, char *s){
//Checks for valid coords
if(row < 0){
row = 0;
}
if(row > dtioRows()){
row = dtioRows() - 1;
}
if(col < 0){
col = 0;
}
if(col > dtioColumns()){
col = dtioColumns() - 1;
}
//Checks for width and location
if((col + width) > dtioColumns()){
width = width - ((col + width) - dtioColumns());
}
initialize(row, col, width, true);
if(strlen(s) > width){
initval = new char[width];
for(int i = 0; i < width; i++){
initval[i] = s[i];
}
}
else{
initval = new char[strlen(s) + 1];
strcpy(initval, s);
}
}
LField::LField(int row, int col, int width, char *s, bool editable){
//Checks for valid coords
if(row < 0){
row = 0;
}
if(row > dtioRows()){
row = dtioRows() - 1;
}
if(col < 0){
col = 0;
}
if(col > dtioColumns()){
col = dtioColumns() - 1;
}
//Checks for width and location
if((col + width) > dtioColumns()){
width = width - ((col + width) - dtioColumns());
}
initialize(row, col, width, editable);
if(strlen(s) > width){
initval = new char[width];
for(int i = 0; i < width; i++){
initval[i] = s[i];
}
}
else{
initval = new char[strlen(s) + 1];
strcpy(initval, s);
}
}
//Function that initializes LField
void LField::initialize(int r, int c, int w, bool e){
row_loc = r;
col_loc = c;
width_tot = w;
edib = e;
index = 0;
}
LField& LField::operator = (const LField & rhs){
if(&rhs != this){
delete [] initval;
initval = new char[strlen(&rhs.initval) + 1]
strcpy(initval, &rhs.initval);
initialize(&rhs.row_loc, &rhs.col_loc, &rhs.width_tot, &rhs.edib);
}
return *this;
}
LField::LField(const LField & source){
delete [] initval;
initval = new char[strlen(&source.initval) + 1]
strcpy(initval, &source.initval);
initialize(&source.row_loc, &source.col_loc, &source.width_tot, &source.edib);
}
void LField::display(){
dtioDisplay(initval, row_loc, col_loc, width_tot);
}
int LField::edit(){
int retval = 0;
if(edib){
retval = dtioEdit(initval, row_loc, col_loc, with_tot, &index);
}
else{
dtioDisplay(initval, row_loc, col_loc, width_tot);
retval = 0
}
return retval;
}
bool LField::editable const(){
return edib;
}
void *LField::data(){
return &initval;
}
void *Field::clone() const{
}Once again I am sorry for the length of the post. I would like to know if I am on the right path with what I am doing and if there is anything that I should change or correct. Any input is greatly appreciated. :)
