i dont know how to solve exercise 1 stepb 1 and 2 my teacher gave us the source
ID: 3875298 • Letter: I
Question
i dont know how to solve exercise 1 stepb 1 and 2
my teacher gave us the source code and told us to solve exercise 1
i attached 2 pictrure of the my hw
and the source code
config.h:
/**
* Text class (Lab 1) configuration file.
* Activate test 'N' by defining the corresponding LAB1_TESTN to have the value 1.
*/
#define LAB1_TEST1 0 // Programming exercise 2: toUpper and toLower
#define LAB1_TEST2 0 // Programming exercise 3: ==, <, and >
Text.h:
//--------------------------------------------------------------------
//
// Laboratory 1 Text.h
// **Instructor's Solution**
// Class declaration for the array implementation of the Text ADT
//
//--------------------------------------------------------------------
#ifndef TEXT_H
#define TEXT_H
#include
#include
using namespace std;
class Text
{
public:
// Constructors and operator=
Text ( const char *charSeq = "" ); // Initialize using char*
Text ( const Text &other ); // Copy constructor
void operator = ( const Text &other ); // Assignment
// Destructor
~Text ();
// Text operations
int getLength () const; // # characters
char operator [] ( int n ) const; // Subscript
void clear (); // Clear string
// Output the string structure -- used in testing/debugging
void showStructure () const;
//--------------------------------------------------------------------
// In-lab operations
// toUpper/toLower operations (Programming Exercise 2)
Text toUpper( ) const; // Create upper-case copy
Text toLower( ) const; // Create lower-case copy
// Relational operations (Programming Exercise 3)
bool operator == ( const Text& other ) const;
bool operator < ( const Text& other ) const;
bool operator > ( const Text& other ) const;
private:
// Data members
int bufferSize; // Size of the string buffer
char *buffer; // Text buffer containing a null-terminated sequence of characters
// Friends
// Text input/output operations (In-lab Exercise 1)
friend istream & operator >> ( istream& input, Text& inputText );
friend ostream & operator << ( ostream& output, const Text& outputText );
};
#endif
test1.cpp:
//--------------------------------------------------------------------
//
// Laboratory 1 test1.cpp
//
// Test program for the operations in the Text ADT
//
//--------------------------------------------------------------------
#include
#include "Text.h"
#include "config.h"
//--------------------------------------------------------------------
//
// Function prototype
void copyTester ( Text copyText ); // copyText is passed by value
void print_help ( );
//--------------------------------------------------------------------
int main()
{
Text a("a"), // Predefined test text objects
alp("alp"),
alpha("alpha"),
epsilon("epsilon"),
empty,
assignText, // Destination for assignment
inputText; // Input text object
int n; // Input subscript
char ch, // Character specified by subscript
selection; // Input test selection
// Get user test selection.
print_help();
// Execute the selected test.
cin >> selection;
cout << endl;
switch ( selection )
{
case '1' :
// Test 1 : Tests the constructors.
cout << "Structure of various text objects: " << endl;
cout << "text object: alpha" << endl;
alpha.showStructure();
cout << "text object: epsilon" << endl;
epsilon.showStructure();
cout << "text object: a" << endl;
a.showStructure();
cout << "empty text object" << endl;
empty.showStructure();
break;
case '2' :
// Test 2 : Tests the length operation.
cout << "Lengths of various text object:" << endl;
cout << " alpha : " << alpha.getLength() << endl;
cout << " epsilon : " << epsilon.getLength() << endl;
cout << " a : " << a.getLength() << endl;
cout << " empty : " << empty.getLength() << endl;
break;
case '3' :
// Test 3 : Tests the subscript operation.
cout << "Enter a subscript : ";
cin >> n;
ch = alpha[n];
cout << " alpha[" << n << "] : ";
if ( ch == '' )
cout << "\0" << endl;
else
cout << ch << endl;
break;
case '4' :
// Test 4 : Tests the assignment and clear operations.
cout << "Assignments:" << endl;
cout << "assignText = alpha" << endl;
assignText = alpha;
assignText.showStructure();
cout << "assignText = a" << endl;
assignText = a;
assignText.showStructure();
cout << "assignText = empty" << endl;
assignText = empty;
assignText.showStructure();
cout << "assignText = epsilon" << endl;
assignText = epsilon;
assignText.showStructure();
cout << "assignText = assignText" << endl;
assignText = assignText;
assignText.showStructure();
cout << "assignText = alpha" << endl;
assignText = alpha;
assignText.showStructure();
cout << "Clear assignText" << endl;
assignText.clear();
assignText.showStructure();
cout << "Confirm that alpha has not been cleared" << endl;
alpha.showStructure();
break;
case '5' :
// Test 5 : Tests the copy constructor and operator= operations.
cout << "Calls by value:" << endl;
cout << "alpha before call" << endl;
alpha.showStructure();
copyTester(alpha);
cout << "alpha after call" << endl;
alpha.showStructure();
cout << "a before call" << endl;
a.showStructure();
a = epsilon;
cout << "a after call" << endl;
a.showStructure();
cout << "epsilon after call" << endl;
epsilon.showStructure();
break;
case '6' : // In-lab Exercise 2
// Test 6 : Tests toUpper and toLower
cout << "Testing toUpper and toLower."
<< "Enter a mixed case string: " << endl;
cin >> inputText;
cout << "Input string:" << endl;
inputText.showStructure();
cout << "Upper case copy: " << endl;
inputText.toUpper().showStructure();
cout << "Lower case copy: " << endl;
inputText.toLower().showStructure();
break;
case '7' : // In-lab Exercise 3
// Test 7 : Tests the relational operations.
cout << " left right < == > " << endl;
cout << "--------------------------------" << endl;
cout << " alpha epsilon " << (alpha << " " << (alpha==epsilon) << " "
<< (alpha>epsilon) << endl;
cout << " epsilon alpha " << (epsilon << " " << (epsilon==alpha) << " "
<< (epsilon>alpha) << endl;
cout << " alpha alpha " << (alpha << (alpha==alpha) << " " << (alpha>alpha)<< endl;
cout << " alp alpha " << (alp << (alp==alpha) << " " << (alp>alpha) << endl;
cout << " alpha alp " << (alpha << (alpha==alp) << " " << (alpha>alp) << endl;
cout << " a alpha " << (a << (a==alpha) << " " << (a>alpha) << endl;
cout << " alpha a " << (alpha << (alpha==a) << " " << (alpha>a) << endl;
cout << " empty alpha " << (empty << (empty==alpha) << " " << (empty>alpha)<< endl;
cout << " alpha empty " << (alpha << (alpha==empty) << " " << (alpha>empty)<< endl;
cout << " empty empty " << (empty << (empty==empty) << " " << (empty>empty)<< endl;
break;
default :
cout << "'" << selection << "' specifies an inactive or invalid test" << endl;
}
system("pause");
return 0;
}
//--------------------------------------------------------------------
void copyTester ( Text copyText )
// Dummy routine that is passed a text object using call by value. Outputs
// copyText and clears it.
{
cout << "Copy of text object" << endl;
copyText.showStructure();
cout << "Clear copy" << endl;
copyText.clear();
copyText.showStructure();
}
//--------------------------------------------------------------------
void print_help()
{
cout << endl << "Tests:" << endl;
cout << " 1 Tests the constructors" << endl;
cout << " 2 Tests the length operation" << endl;
cout << " 3 Tests the subscript operation" << endl;
cout << " 4 Tests the assignment and clear operations"<< endl;
cout << " 5 Tests the copy constructor and operator= operations" << endl;
cout << " 6 Tests the toUpper and toLower operations "
#if LAB1_TEST1
<< "(Active : "
#else
<< "(Inactive : "
#endif // LAB1_TEST1
<< "In-lab Exercise 2)" << endl;
cout << " 7 Tests the relational operations "
#if LAB1_TEST2
<< " (Active : "
#else
<< " (Inactive : "
#endif // LAB1_TEST2
<< "In-lab Exercise 3)" << endl;
cout << "Select the test to run : ";
}
Text.cpp:
#include
#include
#include
#include
#include "Text.h"
Text::Text ( const char *charSeq )
{
bufferSize = strlen(charSeq) + 1;
buffer = new char[bufferSize];
strcpy(buffer, charSeq);
}
Text::Text ( const Text &other )
{
bufferSize = other.bufferSize;
buffer = new char[bufferSize];
strcpy(buffer, other.buffer);
}
void Text::operator = ( const Text &other )
{
int len = other.bufferSize;
if (len > bufferSize)
{
delete[] buffer;
bufferSize = other.bufferSize;
buffer = new char[bufferSize];
}
strcpy(buffer, other.buffer);
}
Text::~Text ()
{
delete[] buffer;
}
int Text::getLength () const
{
return bufferSize - 1;
}
char Text::operator [] ( int n ) const
{
// check if n is out of range first
return 0;
}
void Text::clear ()
{
buffer[0] = '';
}
void Text::showStructure() const
// Outputs the characters in a string. This operation is intended for
// testing/debugging purposes only.
{
int j; // Loop counter
for (j = 0; j < bufferSize; j++)
cout << j << " ";
cout << endl;
for (j = 0; buffer[j] != ''; j++)
cout << buffer[j] << " ";
cout << "\0" << endl;
}
Text Text::toUpper( ) const
{
Text temp;
for (int i = 0; i < bufferSize; i++)
{
if ((buffer[i] > 96 && (buffer[i] < 123)))
{
temp.buffer[i] = char(buffer[i] - 32);
}
}
return temp;
}
Text Text::toLower( ) const
{
Text temp;
for (int i = 0; i < bufferSize; i++)
{
if ((buffer[i] > 64 && (buffer[i] < 91)))
{
temp.buffer[i] = char(buffer[i] + 32);
}
}
return temp;
}
bool Text::operator == ( const Text& other ) const
{
{
if (bufferSize == other.getLength())
{
if (bufferSize == 0)
{
return true;
}
else
{
for (int i = 0; i < bufferSize; i++)
{
if (buffer[i] != other.buffer[i])
{
return false;
}
}
return true;
}
}
else
{
return false;
}
}
}
bool Text::operator < ( const Text& other ) const
{
if (bufferSize < other.getLength())
{
return true;
}
else
{
return false;
}
}
bool Text::operator > ( const Text& other ) const
{
if (bufferSize > other.getLength())
{
return true;
}
else
{
return false;
}
}
textio.cpp:
//--------------------------------------------------------------------
//
// Laboratory 1, In-lab Exercise 1 textio.cpp
//
// String input/output operations
//
//--------------------------------------------------------------------
#include
#include
#include "Text.h"
//--------------------------------------------------------------------
istream & operator >> ( istream &input, Text& inputText )
// Text input function. Extracts a string from istream input and
// returns it in inputText. Returns the state of the input stream.
{
const int textBufferSize = 256; // Large (but finite)
char textBuffer [textBufferSize]; // text buffer
// Read a string into textBuffer, setw is used to prevent buffer
// overflow.
input >> setw(textBufferSize) >> textBuffer;
// Apply the Text(char*) constructor to convert textBuffer to
// a string. Assign the resulting string to inputText using the
// assignment operator.
inputText = textBuffer;
Text ADT1 This format requires that your program maintain a running count of the number of tokens that have been read from the text file. Assume that the tokens in the text file are delimited by whitespace-an assumption that is not true for C++ programs in general. Step 3: Test your lexical analysis program using the C++ program in the file progsamp.dat as input. The contents of this file are shown here. void main ) int j total O for (j-1;jExplanation / Answer
program for implement lexical analyzer.
#include<stdio.h>
#include<ctype.h>
#include<string.h>
void keyw(char*p);
qint i=0,id=0,kw=0,num=0,op=0;
char keys[32][10]={ "auto","break","case","char","const","continue","default","do","double","else",
"enum","extern","float","for","goto","if","int","long","register","return","short","signed","size of","static"
,"struct","switch","typedef","union","unsigned","void","volatile","while"};
int main()
{
Char ch,str[25],sep[15]=" ,;(){}[]#"<>",oper[]="!%^&*+=~|.<>;
int j;
char fname[50];
FILE*f1;
clrscr();
printf("enter the file path(drive:\fold\filename) "); // here you can give your own system path
scanf("%s",fname);
f1=fopen(fname,"r");
if(f1==NULL)
{
printf("file not found");
return 0;
}
while((ch=fgetc(f1))!=EOF)
{
for(j=0;j<=14;j++)
{
if(ch==oper[j])
{
printf("%c is an operatator ",ch);
op++;
str[i]='';
keyw(str);
}
}
for(j=0;j<=14;j++)
{
if(i==-1)
break;
if(ch==seps[j])
{
if(ch=='#')
{
while(ch!='>')
{
printf("%c",ch);
ch=fgetc(f1);
}
printf("%c is a header file ",ch);
i=-1;
break;
}
if(ch=="'')
{
do
{
ch=fgetc(f1);
printf("%c",ch);
}while(ch!="'');
printf(" is an argument ");
i=-1;
break;
}
str[i]='';
keyw(str);
}
}
if(i!=-1)
{
str[i]=ch;
i++;
}
else
i=0;
}
printf("Keywords:%d Identifiers:%d Operators:%d Numbers:%d ",kw,id,op,num);
//getch();
}
void keyw(char *p)
{
int k,flag=0;
for(k=0;k<=3;k++)
{
if(strcmp(keys[k],p==0))
{
printf("%s is akeyword ",p);
kw++;
flag=1;
break;
}
}
if(flag==0)
{
if(isdigit(p[0]))
{
printf("%s is a number ",p);
num++;
}
else
{
//if(p[0]!=13&&p[0]!=10)
if(p[0]!='')
{
printf("%s is an ifdentifier ",p);
id++;
}
}
}
i=-1;
}
output:-
enter the string
Int a,b,c;
a=56;
int keyword
A b c identifier.
=operator
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.