Gain insights into dynamic memory allocation, creating classes, and functions. Delve into inheritance, I/O, exception handling. Explore 90+ examples to master advanced C++ functionalities.

c.tar.gz

ConsoleInputJob

IOjob83

IOjob84

Lesson26and27

If you’re looking to sharpen up your C++ programming skills, then you’re in the right place. You will start with learning about dynamic memory allocation, how to create classes, and constructors. 

In the latter half of the course, inheritance, functions, I/O, exception handling, and more. Throughout the course, you will study over 90 carefully designed examples aimed to enhance your understanding of the C++ language.  

By the time you finish this course, you will be able to use more advanced functionality in your C++ programs.

C++ Programming for Experienced Engineers

# Problem

Write a program that carries out *multiplication* of two polynomials.

# Coding solution
Here is a solution to the problem above.


// Polynomial multiplication

#include <stdio.h>
#include <iostream>

const int MAX = 10 ;

class poly
{
	private :

		struct term
		{
			int coeff ;
			int exp ;
		} t[ MAX ] ;
		int noofterms ;

	public :

		poly( ) ;
		void polyappend ( int c, int e ) ;
		void polyadd ( poly &p1, poly &p2 ) ;
		void polymul ( poly &p1, poly &p2 ) ;
		void display( ) ;
} ;

// initializes data members of class poly
poly :: poly( )
{
	noofterms = 0 ;
	for ( int i = 0 ; i < MAX ; i++ )
	{
		t[ i ].coeff = 0 ;
		t[ i ].exp = 0 ;
	}
}

// adds the term of polynomial to the array t
void poly :: polyappend ( int c, int e )
{
	t[ noofterms ].coeff = c ;
	t[ noofterms ].exp =  e ;
	noofterms++ ;
}

// displays the polynomial equation
void poly :: display( )
{
	int flag = 0 ;
	for ( int i = 0 ; i < noofterms ; i++ )
	{
		if ( t[ i ].exp != 0 )
			std :: cout << t[ i ].coeff << "x^" << t[ i ].exp  << " + " ;
		else
		{
			std :: cout << t[ i ].coeff ;
			flag = 1 ;
		}
	}
	if ( !flag )
		std :: cout << "\b\b  " ;
}

// add two polynomials p1 and p2
void poly :: polyadd ( poly &p1, poly &p2 )
{
	int coeff, exp ;
	poly p ;

	int c = p1.noofterms ;
	int d = p2.noofterms ;

	for ( int i = 0, j = 0 ; i <= c || j <= d ; )
	{
		if ( p1.t[ i ].coeff == 0 && p2.t[ j ].coeff == 0 )
			break ;
		if ( p1.t[ i ].exp >= p2.t[ j ].exp )
		{
			if ( p1.t[ i ].exp == p2.t[ j ].exp )
			{
				coeff = p1.t[ i ].coeff + p2.t[ j ].coeff ;
				exp = p1.t[ i ].exp ;
				i++ ;
				j++ ;
			}
			else
			{
				coeff = p1.t[ i ].coeff ;
				exp = p1.t[ i ].exp ;
				i++ ;
			}
		}
		else
		{
			coeff = p2.t[ j ].coeff ;
			exp = p2.t[ j ].exp ;
			j++ ;
		}
		p.polyappend ( coeff, exp ) ;
	}
	*this = p ;
}

// multiply two polynomials p1 and p2
void poly :: polymul ( poly &p1, poly &p2 )
{
	int coeff, exp ;
	poly t1, t2 ;

	if ( p1.noofterms != 0 && p2.noofterms != 0 )
	{
		for ( int i = 0 ; i < p1.noofterms ; i++ )
		{
			poly p ;
			for ( int j = 0 ; j < p2.noofterms ; j++ )
			{
				coeff = p1.t[  i  ].coeff * p2.t[  j  ].coeff ;
				exp = p1.t[  i  ].exp + p2.t[  j  ].exp ;
				p.polyappend ( coeff, exp ) ;
			}

			if ( i != 0 )
			{
				t2.polyadd ( t1, p ) ;
				t1 = t2  ;
			}
			else
				t1 = p ;
		}

		*this = t2 ;
	}
}

int  main( )
{
	poly p1 ;

	p1.polyappend ( 1, 4 ) ;
	p1.polyappend ( 2, 3 ) ;
	p1.polyappend ( 2, 2 ) ;
	p1.polyappend ( 2, 1 ) ;

	poly p2 ;
	p2.polyappend ( 2, 3 ) ;
	p2.polyappend ( 3, 2 ) ;
	p2.polyappend ( 4, 1 ) ;

	poly p3 ;
	p3.polymul( p1, p2 ) ;

	std :: cout << std :: endl << "First polynomial: " << std :: endl  ;
	p1.display( ) ;

	std :: cout << std :: endl << "Second polynomial: " << std :: endl ;
	p2.display( ) ;

	std :: cout << std :: endl << "Resultant polynomial: " << std :: endl ;
	p3.display( ) ;

	return 0 ;
}


# Explanation	 	                        

To carry out the multiplication of two given polynomial equations, the `poly` class contains one more function, `polymul( )`. We have called the `polyappend( )` function several times to build the two polynomials, which are represented by the objects `p1` and `p2`. Next, the function `polymul( )` is called through the object `p3` to carry out the multiplication of two polynomials. 
In the `polymul( )` function, first we check if the two objects `p1` and `p2` are non-empty. If they are not, then the control enters a pair of for loops. Here each term of the first polynomial contained in `p1` is multiplied with every term of the second polynomial contained in `p2`. While doing so we have called `polyappend( )` to add the terms to `p`. The first resultant polynomial is stored in the temporary object `t1` of the `poly` class. From there onwards, the function `polyadd( )` is called to add the resulting polynomials. 
Lastly, the terms of the resulting polynomial are displayed using the function `display()`.

Understand the multiplication of two polynomials.  

Example: Polynomial Class Extension

Understand the multiplication of two polynomials.

Getting Off the Ground

Starters

Basic C++ Examples

Class Organization Examples

Class Constructor Examples

Classes and Objects Examples

More Classes and Objects Examples

Function Examples

Function Overloading Examples

Operator Overloading Examples

Free Store Examples

Inheritance Examples

Virtual Function Examples

Input Output Examples

Template Examples

Exception Handling Examples

STL Examples

Miscellaneous Examples

Conclusion

Polynomial Class Extension

Problem