Algorithms | Student Projects

C++ program to implement three classes using multiple inheritance

Editorial Team — Sat, 13 Mar 2010 15:11:45 +0000

MULTIPLE INHERITANCES

AIM:
Write a program to illustrating how all the three classes are implemented in multiple inheritance mode

ALGORITHM
• Start the process
• Invoke the class M
• Invoke the another class N
• Invoke one more class,ie class P,which is inherited by both M and N
• Create an object for class p,ie P p
• Call p.get_m(),assign the value in to ‘m’
• Call p.get_n(),assign the value in to ‘n’
• Call display(), for dispay the result
• Stop the result

PROGRAM:

	#include
	#include
	
	Class M
        {
		Protected:
		Int m;
		Public :
		Void get_M();
	};
	Class N
        {		
		Protected:
		Int n;
		Public:
		Void get_N();
	};
	Class p: public M, public N 		
	{
		Public:
		Void disply(void);
	};
	Void M ::get_m(int x)
	{
		m=x;
	}
	Void N::get_n(int y)
	{
		n=y;
	}
	Void P:: disply(void)
	{
	Cout<<”m=”<
OUTPUT
	m=10

	n=20

	m*n=200
The post C++ program to implement three classes using multiple inheritance first appeared on Student Projects.

C++ program to print student details using constructor and destructor

Editorial Team — Fri, 12 Mar 2010 18:22:49 +0000

AIM:

A program to print student details using a constructor and destructor.

ALGORITHM:

Start the process
Invoke the classes
Call the read() function
- Get the inputs name, roll number and address
Call the display() function
- Display the name, roll number, and address of the student
Stop the process

PROGRAM

#include 
using namespace std;

class student
{
	private: char name[20],add[20];
	  	int roll,zip;
	public: student ( ); //Constructor
		~student( ); //Destructor
		void read( );
		void disp( );			
};

student :: student( )
{
	cout<<"Student class constructor called."<>name;
	cout<<"Enter the student roll no: “;
	cin>>roll;
	cout<<"Enter the student address: ";
	cin>>add;
	cout<<"Enter the Zipcode: ";
	cin>>zip;
}

void student :: disp( )
{
	cout<<"Studet details"<





Output:



Student class constructor called.

Enter the student Name: Rajesh
Enter the student roll no: 1234
Enter the student address: Bangalore
Enter the Zipcode: 560001

Studet details
Student Name   :Rajesh
Roll no is     :1234
Address is     :Bangalore
Zipcode is     :560001

Student class destructor called.



The post C++ program to print student details using constructor and destructor first appeared on Student Projects.



C++ program for implementation of class
Editorial Team — Fri, 12 Mar 2010 09:45:07 +0000
AIM: 	

	A program to solve a quadratic equation, using OOP techniques.
ALGORITHM: 
1)	Start the process

2)	Invoke the classes

3)	Get the input for a,b,c;

4)	Call the function getinfo() and display()

5)	Check if a=0

a)	True : compute c/b;

i)	Print the value of a/c;

b)	False: compute b*b-4*a*c;

i)	If ( b*b-4*a*c)=0

ii)	Call img();

iii)	Otherwise : call real(a,b,c);

6)	Stop the process
PROGRAM:
	#include
	#include
		class equation
		{
			private:float a,b,c;
			public: void getinfo(float  a, float b,float c );
				void display( );
				void equal(float  a, float b);
				void imag( );
				void real(float a,float b,float c);
		};
		void  equation :: getinfo(float aa,float bb,float cc)
		{
	                a=aa;
			b=bb;
		        c=cc;
		}
		void equation::display( )
		{
			cout<>aa>>bb>>cc;
			e.getinfo(aa,bb,cc);
			e.display( );
			if(aa = =0)
			{
				float temp;
				temp = cc/bb;
				cout<<” Linear Roots”<
OUTPUT:

	Enter the three numbers 2 4 1

	Roots are imaginary

	X1= - 0.292893

	X2= - 1.707107
The post C++ program for implementation of class first appeared on Student Projects.


Lexical Analyzer
Editorial Team — Thu, 20 Nov 2008 07:37:32 +0000
Lexical analyzer converts stream of input characters into a stream of tokens. The different tokens that our lexical analyzer identifies are as follows:
KEYWORDS: int, char, float, double, if, for, while, else, switch, struct, printf, scanf, case, break, return, typedef, void
IDENTIFIERS: main, fopen, getch etc
NUMBERS: positive and negative integers, positive and negative floating point numbers.
OPERATORS: +, ++, -, –, ||, *, ?, /, >, >=, <, <=, =, ==, &, &&.
BRACKETS: [ ], { }, ( ).
STRINGS : Set of characters enclosed within the quotes
COMMENT LINES: Ignores single  line, multi line comments
For tokenizing into identifiers and keywords we incorporate a symbol table which initially consists of predefined keywords. The tokens are read from an input file. If the encountered token is an identifier or a keyword the lexical analyzer will look up in the symbol table to check  the existence  of the respective token. If an entry does exist then we proceed to the next  token. If not then that particular  token along with the token value is written into the symbol table. The rest of the tokens are directly displayed by writing into an output file.
The output file will consist of all the tokens present in our input file along with their respective token values.
INTRODUCTION:
Lexical analysis involves scanning the program to be compiled and recognizing the tokens that make up the source statements Scanners or lexical analyzers are usually designed to recognize keywords , operators , and identifiers , as well as integers, floating point numbers , character strings , and other  similar items that are written as part of the source program . The exact set of  tokens to be recognized of course, depends upon the programming language being used to describe it.
A sequence of input characters that comprises a single token is called a lexeme. A lexical analyzer can insulate a parser from the lexeme representation of tokens. Following are the list of functions that lexical analyzers perform.
Removal of white space and  comment :
Many languages allow “white space” to appear between tokens. Comments can likewise be ignored by the parser and translator , so they may also be treated as white space. If white space is eliminated by the lexical analyzer, the parser will never have to consider it.
Constants :
An integer constant is a sequence of digits, integer constants can be allowed by adding productions to the grammar for expressions, or by creating a token for such constants . The job of collecting digits into integers is generally given to a lexical analyzer because numbers can be treated as single units during translation. The lexical analyzer passes both the token and attribute to the parser.



Recognizing identifiers and keywords :
Languages use identifiers as names of variables, arrays and functions. A grammar for a language often treats an identifier as a token. Many languages use fixed character strings such as begin, end , if, and so on, as punctuation marks or to identify certain constructs. These character strings, called keywords, generally satisfy the rules for forming identifiers.
SYSTEM ANALYSIS:
The operating  system used is MS-DOS.
MS-DOS : The MS-DOS is a single user, single process, single processor operating system. Due to the confinement of the device dependent code into one layer, the porting of MS-DOS has theoretically been reduced to writing  of the BIOS code for the new hardware. At the command level it provides a hierarchical file system, input output redirection, pipes and filters. User written commands can be invoked in the same way as the standard system commands, giving the appearance as if the basic system functionality has been extended.
Being a single user system, it provides only file protection and access control. The disk space is allocated in terms of a cluster of consecutive sectors. The command language of MS-DOS has been designed to allow the user to interact directly with the operating system using a CRT terminal. The principal use of the command language is to initiate the execution of commands and programs. A user program can be executed under MS-DOS by simply typing the name of the executable file of the user program at the DOS command prompt.
The programming language used here is C programming
SYSTEM DESIGN:
Process:
The lexical analyzer is the first phase of  a compiler. Its main task is to read the input characters and produce as output a sequence of tokens that the parser uses for syntax analysis. This interaction, summarized schematically in fig. a.
fig a. Process of lexical analyzer 

Upon receiving a “get next token “command from the parser, the lexical analyzer reads the input characters until it can identify next token.
Sometimes , lexical analyzers are divided into a cascade of two phases, the first called “scanning”, and the second “lexical analysis”.
The scanner is responsible for doing simple tasks, while the lexical analyzer proper does the more complex operations.
The lexical analyzer which we have designed takes the input  from a input file. It reads one character at a time from the input file, and continues to read until end of the file is reached. It recognizes the valid identifiers, keywords and specifies the token values of the keywords.
It also identifies the header files, #define statements, numbers, special characters, various relational and logical operators, ignores the white spaces and comments. It prints the output in a separate file specifying the line number .
BLOCK DIAGRAM:
fig b. Block diagram of the project
The post Lexical Analyzer first appeared on Student Projects.