c++ – Page 3 – My Programming Notes

Tag Archives: c++

C++ || How To Convert A String To Upper and Lower Case Using C++

December 05, 2020 admin No comments

The following is a module with functions which demonstrates how to convert a string to all upper and lower case using C++.

1. To Upper Case

The example below demonstrates the use of ‘Utils::toUpperCase‘ to convert a string to all upper case.





		
		
			1. To Upper Case
			
C++
			
			// To Upper Case

// Declare word
std::string word = "Kenneth, Jennifer, Lynn, Sole";

// Convert to uppercase
auto result = Utils::toUpperCase(word);

std::cout << result;

// expected output:
/*
    KENNETH, JENNIFER, LYNN, SOLE
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						// To Upper Case
 
// Declare word
std::string word = "Kenneth, Jennifer, Lynn, Sole";
 
// Convert to uppercase
auto result = Utils::toUpperCase(word);
 
std::cout << result;
 
// expected output:
/*
    KENNETH, JENNIFER, LYNN, SOLE
*/

2. To Lower Case

The example below demonstrates the use of ‘Utils::toLowerCase‘ to convert a string to all lower case.





		
		
			2. To Lower Case
			
C++
			
			// To Lower Case

// Declare word
std::string word = "Kenneth, Jennifer, Lynn, Sole";

// Convert to lowercase
auto result = Utils::toLowerCase(word);

std::cout << result;

// expected output:
/*
    kenneth, jennifer, lynn, sole
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						// To Lower Case
 
// Declare word
std::string word = "Kenneth, Jennifer, Lynn, Sole";
 
// Convert to lowercase
auto result = Utils::toLowerCase(word);
 
std::cout << result;
 
// expected output:
/*
    kenneth, jennifer, lynn, sole
*/

3. Utils Namespace

The following is the Utils Namespace. Include this in your project to start using!





		
		
			Utils Namespace
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  Utils.h
//    Description: Handles general utility functions
// ============================================================================
#pragma once
#include <string>
#include <cctype>
#include <algorithm>

namespace Utils {
    /**
    * FUNCTION: toUpperCase 
    * USE: Converts a string to all uppercase
    * @param source: The source string
    * @return: The modified source string
    */
    std::string toUpperCase(std::string source) {
        std::transform(source.begin(), source.end(), source.begin(), [](unsigned char c) {
            return static_cast<unsigned char>(std::toupper(c));
        });
        return source;
    }

    /**
    * FUNCTION: toLowerCase 
    * USE: Converts a string to all lowercase
    * @param source: The source string
    * @return: The modified source string
    */
    std::string toLowerCase(std::string source) {
        std::transform(source.begin(), source.end(), source.begin(), [](unsigned char c) {
            return static_cast<unsigned char>(std::tolower(c));
        });
        return source;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  Utils.h
//    Description: Handles general utility functions
// ============================================================================
#pragma once
#include <string>
#include <cctype>
#include <algorithm>
 
namespace Utils {
    /**
    * FUNCTION: toUpperCase 
    * USE: Converts a string to all uppercase
    * @param source: The source string
    * @return: The modified source string
    */
    std::string toUpperCase(std::string source) {
        std::transform(source.begin(), source.end(), source.begin(), [](unsigned char c) {
            return static_cast<unsigned char>(std::toupper(c));
        });
        return source;
    }
 
    /**
    * FUNCTION: toLowerCase 
    * USE: Converts a string to all lowercase
    * @param source: The source string
    * @return: The modified source string
    */
    std::string toLowerCase(std::string source) {
        std::transform(source.begin(), source.end(), source.begin(), [](unsigned char c) {
            return static_cast<unsigned char>(std::tolower(c));
        });
        return source;
    }
}// http://programmingnotes.org/

4. More Examples

Below are more examples demonstrating the use of the ‘Utils‘ Namespace. Don’t forget to include the module when running the examples!





		
		
			More Examples
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  program.cpp
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
#include <iostream>
#include <string>
#include <exception>
#include "Utils.h"

void display(const std::string& message);

int main() {
    try {
        // Declare word
        std::string word = "Kenneth, Jennifer, Lynn, Sole";

        // Convert to uppercase
        auto result = Utils::toUpperCase(word);

        display(result);

        // Convert to lowercase
        auto result2 = Utils::toLowerCase(word);

        display(result2);
    } catch (std::exception& e) {
        display("\nAn error occurred: " + std::string(e.what()));
    }

    std::cin.get();
    return 0;
}

void display(const std::string& message) {
    std::cout << message << std::endl;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  program.cpp
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
#include <iostream>
#include <string>
#include <exception>
#include "Utils.h"
 
void display(const std::string& message);
 
int main() {
    try {
        // Declare word
        std::string word = "Kenneth, Jennifer, Lynn, Sole";
 
        // Convert to uppercase
        auto result = Utils::toUpperCase(word);
 
        display(result);
 
        // Convert to lowercase
        auto result2 = Utils::toLowerCase(word);
 
        display(result2);
    } catch (std::exception& e) {
        display("\nAn error occurred: " + std::string(e.what()));
    }
 
    std::cin.get();
    return 0;
}
 
void display(const std::string& message) {
    std::cout << message << std::endl;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

C++ || How To Remove All Whitespace From A String Using C++

December 05, 2020 admin No comments

The following is a module with functions which demonstrates how to remove all whitespace from a string using C++.

1. Remove All Whitespace

The example below demonstrates the use of ‘Utils::RemoveWhitespace‘ to remove all whitespace from a string.





		
		
			1. Remove All Whitespace
			
C++
			
			// Remove All Whitespace

// Declare word
std::string word = "This   document uses 3 other documents ";

// Remove whitespace from the string
auto result = Utils::removeAllWhitespace(word);

std::cout << result;

/*
 expected output:
    Thisdocumentuses3otherdocuments
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						// Remove All Whitespace
 
// Declare word
std::string word = "This   document uses 3 other documents ";
 
// Remove whitespace from the string
auto result = Utils::removeAllWhitespace(word);
 
std::cout << result;
 
/*
 expected output:
    Thisdocumentuses3otherdocuments
*/

2. Utils Namespace

The following is the Utils Namespace. Include this in your project to start using!





		
		
			Utils Namespace
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  Utils.h
//    Description: Handles general utility functions
// ============================================================================
#pragma once
#include <string> 
#include <cctype>
#include <algorithm>

namespace Utils {
    /**
    * FUNCTION: removeAllWhitespace 
    * USE: Removes all whitespace from a string
    * @param source: The source string
    * @return: The modified source string
    */
    std::string removeAllWhitespace(std::string source) {
        source.erase(std::remove_if(source.begin(), source.end(), [](char c) { 
            return std::isspace(static_cast<unsigned char>(c)); 
        }), source.end());
        return source;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  Utils.h
//    Description: Handles general utility functions
// ============================================================================
#pragma once
#include <string> 
#include <cctype>
#include <algorithm>
 
namespace Utils {
    /**
    * FUNCTION: removeAllWhitespace 
    * USE: Removes all whitespace from a string
    * @param source: The source string
    * @return: The modified source string
    */
    std::string removeAllWhitespace(std::string source) {
        source.erase(std::remove_if(source.begin(), source.end(), [](char c) { 
            return std::isspace(static_cast<unsigned char>(c)); 
        }), source.end());
        return source;
    }
}// http://programmingnotes.org/

3. More Examples

Below are more examples demonstrating the use of the ‘Utils‘ Namespace. Don’t forget to include the module when running the examples!





		
		
			More Examples
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  program.cpp
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
#include <iostream>
#include <string>
#include <exception>
#include "Utils.h"

void display(const std::string& message);

int main() {
    try {
        // Declare word
        std::string word = "This   document uses 3 other documents ";

        // Remove whitespace from the string
        auto result = Utils::removeAllWhitespace(word);

        display(result);
    } catch (std::exception& e) {
        display("\nAn error occurred: " + std::string(e.what()));
    }

    std::cin.get();
    return 0;
}

void display(const std::string& message) {
    std::cout << message << std::endl;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  program.cpp
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
#include <iostream>
#include <string>
#include <exception>
#include "Utils.h"
 
void display(const std::string& message);
 
int main() {
    try {
        // Declare word
        std::string word = "This   document uses 3 other documents ";
 
        // Remove whitespace from the string
        auto result = Utils::removeAllWhitespace(word);
 
        display(result);
    } catch (std::exception& e) {
        display("\nAn error occurred: " + std::string(e.what()));
    }
 
    std::cin.get();
    return 0;
}
 
void display(const std::string& message) {
    std::cout << message << std::endl;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

C++ || How To Get The File Path, File Name & File Extension From A Path Using C++

December 05, 2020 admin No comments

The following is a module with functions which demonstrates how to parse a file path, file name and file extension from a path using C++.

1. Get File Path

The example below demonstrates the use of ‘Utils::getFilePath‘ to parse and get the file path from a path.





		
		
			1. Get File Path
			
C++
			
			// Get File Path

// Declare path
std::string path = "C:\\Users\\Name\\Desktop\\20171216_155433.jpg";

// Get the file path
auto filePath = Utils::getFilePath(path);

std::cout << "Path: " << path << std::endl;
std::cout << "File Path: " << filePath;

// expected output:
/*
    Path: C:\Users\Name\Desktop\20171216_155433.jpg
    File Path: C:\Users\Name\Desktop
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						// Get File Path
 
// Declare path
std::string path = "C:\\Users\\Name\\Desktop\\20171216_155433.jpg";
 
// Get the file path
auto filePath = Utils::getFilePath(path);
 
std::cout << "Path: " << path << std::endl;
std::cout << "File Path: " << filePath;
 
// expected output:
/*
    Path: C:\Users\Name\Desktop\20171216_155433.jpg
    File Path: C:\Users\Name\Desktop
*/

2. Get File Name

The example below demonstrates the use of ‘Utils::getFileName‘ to parse and get the file name from a path.





		
		
			2. Get File Name
			
C++
			
			// Get File Name

// Declare path
std::string path = "C:\\Users\\Name\\Desktop\\20171216_155433.jpg";

// Get the file name
auto fileName = Utils::getFileName(path);

std::cout << "Path: " << path << std::endl;
std::cout << "File Name: " << fileName;

// expected output:
/*
    Path: C:\Users\Name\Desktop\20171216_155433.jpg
    File Name: 20171216_155433.jpg
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						// Get File Name
 
// Declare path
std::string path = "C:\\Users\\Name\\Desktop\\20171216_155433.jpg";
 
// Get the file name
auto fileName = Utils::getFileName(path);
 
std::cout << "Path: " << path << std::endl;
std::cout << "File Name: " << fileName;
 
// expected output:
/*
    Path: C:\Users\Name\Desktop\20171216_155433.jpg
    File Name: 20171216_155433.jpg
*/

3. Get File Name Extension

The example below demonstrates the use of ‘Utils::getFileExtension‘ to parse and get the file extension from a path.





		
		
			3. Get File Name Extension
			
C++
			
			// Get File Name Extension

// Declare path
std::string path = "C:\\Users\\Name\\Desktop\\20171216_155433.jpg";

// Get the file extension
auto extension = Utils::getFileExtension(path);

std::cout << "Path: " << path << std::endl;
std::cout << "File Extension: " << extension;

// expected output:
/*
    Path: C:\Users\Name\Desktop\20171216_155433.jpg
    File Extension: jpg
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						// Get File Name Extension
 
// Declare path
std::string path = "C:\\Users\\Name\\Desktop\\20171216_155433.jpg";
 
// Get the file extension
auto extension = Utils::getFileExtension(path);
 
std::cout << "Path: " << path << std::endl;
std::cout << "File Extension: " << extension;
 
// expected output:
/*
    Path: C:\Users\Name\Desktop\20171216_155433.jpg
    File Extension: jpg
*/

4. Utils Namespace

The following is the Utils Namespace. Include this in your project to start using!





		
		
			Utils Namespace
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  Utils.h
//    Description: Handles general utility functions
// ============================================================================
#pragma once
#include <string>
#include <algorithm>
#include <cctype>

namespace Utils {
    /**
    * FUNCTION: getFilePath 
    * USE: Returns the path from a given file path
    * @param path: The path of the file
    * @return: The path from the given file path
    */
    std::string getFilePath(const std::string& path) {
        auto pathEnd = path.find_last_of("/\\");
        auto pathName = pathEnd == std::string::npos ? path : path.substr(0, pathEnd);
        return pathName;
    }

    /**
    * FUNCTION: getFileName 
    * USE: Returns the file name from a given file path
    * @param path: The path of the file
    * @return: The file name from the given file path
    */
    std::string getFileName(const std::string& path) {
        auto fileNameStart = path.find_last_of("/\\");
        auto fileName = fileNameStart == std::string::npos ? path : path.substr(fileNameStart + 1);
        return fileName;
    }

    /**
    * FUNCTION: getFileExtension 
    * USE: Returns the file extension from a given file path
    * @param path: The path of the file
    * @return: The file extension from the given file path
    */
    std::string getFileExtension(const std::string& path) {
        auto fileName = getFileName(path);
        auto extStart = fileName.find_last_of('.');
        auto ext = extStart == std::string::npos ? "" : fileName.substr(extStart + 1);
        std::transform(ext.begin(), ext.end(), ext.begin(), [](unsigned char c) { 
            return static_cast<unsigned char>(std::tolower(c)); 
        });
        return ext;
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  Utils.h
//    Description: Handles general utility functions
// ============================================================================
#pragma once
#include <string>
#include <algorithm>
#include <cctype>
 
namespace Utils {
    /**
    * FUNCTION: getFilePath 
    * USE: Returns the path from a given file path
    * @param path: The path of the file
    * @return: The path from the given file path
    */
    std::string getFilePath(const std::string& path) {
        auto pathEnd = path.find_last_of("/\\");
        auto pathName = pathEnd == std::string::npos ? path : path.substr(0, pathEnd);
        return pathName;
    }
 
    /**
    * FUNCTION: getFileName 
    * USE: Returns the file name from a given file path
    * @param path: The path of the file
    * @return: The file name from the given file path
    */
    std::string getFileName(const std::string& path) {
        auto fileNameStart = path.find_last_of("/\\");
        auto fileName = fileNameStart == std::string::npos ? path : path.substr(fileNameStart + 1);
        return fileName;
    }
 
    /**
    * FUNCTION: getFileExtension 
    * USE: Returns the file extension from a given file path
    * @param path: The path of the file
    * @return: The file extension from the given file path
    */
    std::string getFileExtension(const std::string& path) {
        auto fileName = getFileName(path);
        auto extStart = fileName.find_last_of('.');
        auto ext = extStart == std::string::npos ? "" : fileName.substr(extStart + 1);
        std::transform(ext.begin(), ext.end(), ext.begin(), [](unsigned char c) { 
            return static_cast<unsigned char>(std::tolower(c)); 
        });
        return ext;
    }
}// http://programmingnotes.org/

5. More Examples

Below are more examples demonstrating the use of the ‘Utils‘ Namespace. Don’t forget to include the module when running the examples!





		
		
			More Examples
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  program.cpp
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
#include <iostream>
#include <string>
#include <exception>
#include "Utils.h"

void display(const std::string& message);

int main() {
    try {
        // Declare path
        std::string path = "C:\\Users\\Name\\Desktop\\20171216_155433.jpg";

        // Get the file path
        auto filePath = Utils::getFilePath(path);

        display("Path: " + path + ", File Path: " + filePath);
        
        // Get the filename
        auto fileName = Utils::getFileName(path);

        display("Path: " + path + ", File Name: " + fileName);

        // Get the file extension
        auto extension = Utils::getFileExtension(path);

        display("Path: " + path + ", File Extension: " + extension);

    } catch (std::exception& e) {
        display("\nAn error occurred: " + std::string(e.what()));
    }

    std::cin.get();
    return 0;
}

void display(const std::string& message) {
    std::cout << message << std::endl;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Dec 5, 2020
//    Taken From: http://programmingnotes.org/
//    File:  program.cpp
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
#include <iostream>
#include <string>
#include <exception>
#include "Utils.h"
 
void display(const std::string& message);
 
int main() {
    try {
        // Declare path
        std::string path = "C:\\Users\\Name\\Desktop\\20171216_155433.jpg";
 
        // Get the file path
        auto filePath = Utils::getFilePath(path);
 
        display("Path: " + path + ", File Path: " + filePath);
        
        // Get the filename
        auto fileName = Utils::getFileName(path);
 
        display("Path: " + path + ", File Name: " + fileName);
 
        // Get the file extension
        auto extension = Utils::getFileExtension(path);
 
        display("Path: " + path + ", File Extension: " + extension);
 
    } catch (std::exception& e) {
        display("\nAn error occurred: " + std::string(e.what()));
    }
 
    std::cin.get();
    return 0;
}
 
void display(const std::string& message) {
    std::cout << message << std::endl;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

C++ || Roman Numeral Conversion – How To Convert Roman Numeral To Integer & Integer To Roman Numeral Using C++

November 02, 2020 admin No comments

The following is a program with functions which demonstrates how to convert roman numerals to integer, and integers to roman numerals.

The sample program implemented on this page is an updated version of a homework assignment which was presented in a C++ Data Structures course. This program was assigned in order to practice the use of the class data structure, which is very similar to the struct data structure.

1. Roman Numeral Conversion

The example below demonstrates how to convert integers to roman numerals and roman numerals to integers.





		
		
			1. Roman Numeral Conversion
			
C++
			
			// ============================================================================
//   Author:  Kenneth Perkins
//   Taken From: http://programmingnotes.org/
//   Date:  Nov 2, 2020
//   File: romanNumeralConversion.cpp
//   Description: The following demonstrates how to convert roman numerals.
// ============================================================================
#include <iostream>
#include <vector>
#include <string>
#include <cctype>
#include <algorithm>

/**
* USE: Converts values from decimal to roman numeral and back
*/
class RomanNumeral {

private:
    double m_decimal;
    std::string m_roman;
    bool m_isEmpty;

public:
    RomanNumeral() {
        this->m_isEmpty = true;
    }

    RomanNumeral(double decimal, std::string roman) {
        this->m_decimal = decimal;
        this->m_roman = roman;
        this->m_isEmpty = false;
    }

    double decimal() const {
        return this->m_decimal;
    }

    std::string roman() const { 
        return this->m_roman;
    }

    bool isEmpty() const {
        return this->m_isEmpty;
    }

    /**
    * FUNCTION: convertToRoman
    * USE: Converts a decimal number to a roman numeral
    * @param decimal: The number to be converted to a roman numeral.
    * @return: The converted roman numeral value.
    */
    static std::string convertToRoman(double decimal) {
        std::string roman = "";

        if (decimal > 0) {
            auto conversionValues = getValues();
            for (const auto& conversionValue : conversionValues) {
                while (decimal > 0
                    && decimal >= conversionValue.decimal()) {
                    roman += conversionValue.roman();
                    decimal -= conversionValue.decimal();
                }
                if (decimal <= 0) {
                    break;
                }
            }
        }
        return roman;
    }

    /**
    * FUNCTION: convertToDecimal
    * USE: Converts a roman numeral to a decimal value
    * @param roman: The number to be converted to a decimal number.
    * @return: The converted decimal value.
    */
    static double convertToDecimal(std::string roman) {
        double decimal = 0;

        if (!isEmpty(roman)) {
            double previousNumber = 0;
            auto conversionValues = getValues();

            // Iterate the std::string starting from the end
            for (int index = roman.length() - 1; index >= 0; --index) {
                // Get the current letter
                std::string currentLetter = std::string(1, roman[index]);

                // Skip whitepsace characters
                if (isEmpty(currentLetter)) {
                    continue;
                }

                // Find a conversion value that matches the current letter
                auto conversionValue = find(conversionValues, currentLetter);

                // If a valid conversion was found, get the value
                if (conversionValue.isEmpty()) {
                    continue;
                }

                auto currentNumber = conversionValue.decimal();

                // Calculate the result
                if (previousNumber > currentNumber) {
                    decimal -= currentNumber;
                } else {
                    decimal += currentNumber;
                }

                // Save the current number in order to process the next letter
                previousNumber = currentNumber;
            }
        }

        return decimal;
    }

    // Returns roman Numeral Conversion Values
    static std::vector<RomanNumeral> getValues() {
        std::vector<RomanNumeral> conversionValues;

        conversionValues.push_back(RomanNumeral(1000, "M"));
        conversionValues.push_back(RomanNumeral(900, "CM"));
        conversionValues.push_back(RomanNumeral(500, "D"));
        conversionValues.push_back(RomanNumeral(400, "CD"));
        conversionValues.push_back(RomanNumeral(100, "C"));
        conversionValues.push_back(RomanNumeral(90, "XC"));
        conversionValues.push_back(RomanNumeral(50, "L"));
        conversionValues.push_back(RomanNumeral(40, "XL"));
        conversionValues.push_back(RomanNumeral(10, "X"));
        conversionValues.push_back(RomanNumeral(9, "IX"));
        conversionValues.push_back(RomanNumeral(5, "V"));
        conversionValues.push_back(RomanNumeral(4, "IV"));
        conversionValues.push_back(RomanNumeral(1, "I"));

        // Sort the list in descending roman numeral order
        std::sort(conversionValues.begin(), conversionValues.end(), [](const auto& lhs, const auto& rhs) {
            return lhs.decimal() > rhs.decimal();
        });

        return conversionValues;
    }

    // Finds a conversion that matches the given roman numeral search value
    static RomanNumeral find(std::vector<RomanNumeral> conversionValues, std::string searchValue) {
        RomanNumeral result;

        searchValue = toLower(searchValue);
        auto predicate = [searchValue](auto x) { return (toLower(x.roman()) == searchValue); };
        auto iter = std::find_if(conversionValues.begin(), conversionValues.end(), predicate);
        if (iter != conversionValues.end()) {
            result = *iter;
        }
        return result;
    }

    // Checks if a string is empty or only contains whitespace
    static bool isEmpty(std::string str) {
        return str.empty()
            || std::all_of(str.begin(), str.end(), [](char c) {
                return std::isspace(static_cast<unsigned char>(c));
            });
    }

    // Converts a string to lowercase
    static std::string toLower(std::string str) {
        std::transform(str.begin(), str.end(), str.begin(),
            [](char c) { return std::tolower(static_cast<unsigned char>(c)); });
        return str;
    }
};

void display(std::string message) {
    message += "\n";
    std::cout << message;
}

void romanTest(std::string roman) {
    auto decimal = RomanNumeral::convertToDecimal(roman);
    auto convertedBack = RomanNumeral::convertToRoman(decimal);

    display("======= Roman Test Start =======");

    display("Original = " + roman
        + "\n Converted = " + std::to_string(decimal)
        + "\n Converted Back To Original = " + convertedBack);

    display("======= Roman Test End =======");
}

void decimalTest(double decimal) {
    auto roman = RomanNumeral::convertToRoman(decimal);
    auto convertedBack = RomanNumeral::convertToDecimal(roman);

    display("======= Decimal Test Start =======");

    display("Original = " + std::to_string(decimal)
        + "\n Converted = " + roman 
        + "\n Converted Back To Original = " + std::to_string(convertedBack));

    display("======= Decimal Test End =======");
}

int main() {
    auto decimal = 1987;
    decimalTest(decimal);

    display("");

    auto roman = "McMxcI";
    romanTest(roman);

    std::cin.get();
    return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
				
						// ============================================================================
//   Author:  Kenneth Perkins
//   Taken From: http://programmingnotes.org/
//   Date:  Nov 2, 2020
//   File: romanNumeralConversion.cpp
//   Description: The following demonstrates how to convert roman numerals.
// ============================================================================
#include <iostream>
#include <vector>
#include <string>
#include <cctype>
#include <algorithm>
 
/**
* USE: Converts values from decimal to roman numeral and back
*/
class RomanNumeral {
 
private:
    double m_decimal;
    std::string m_roman;
    bool m_isEmpty;
 
public:
    RomanNumeral() {
        this->m_isEmpty = true;
    }
 
    RomanNumeral(double decimal, std::string roman) {
        this->m_decimal = decimal;
        this->m_roman = roman;
        this->m_isEmpty = false;
    }
 
    double decimal() const {
        return this->m_decimal;
    }
 
    std::string roman() const { 
        return this->m_roman;
    }
 
    bool isEmpty() const {
        return this->m_isEmpty;
    }
 
    /**
    * FUNCTION: convertToRoman
    * USE: Converts a decimal number to a roman numeral
    * @param decimal: The number to be converted to a roman numeral.
    * @return: The converted roman numeral value.
    */
    static std::string convertToRoman(double decimal) {
        std::string roman = "";
 
        if (decimal > 0) {
            auto conversionValues = getValues();
            for (const auto& conversionValue : conversionValues) {
                while (decimal > 0
                    && decimal >= conversionValue.decimal()) {
                    roman += conversionValue.roman();
                    decimal -= conversionValue.decimal();
                }
                if (decimal <= 0) {
                    break;
                }
            }
        }
        return roman;
    }
 
    /**
    * FUNCTION: convertToDecimal
    * USE: Converts a roman numeral to a decimal value
    * @param roman: The number to be converted to a decimal number.
    * @return: The converted decimal value.
    */
    static double convertToDecimal(std::string roman) {
        double decimal = 0;
 
        if (!isEmpty(roman)) {
            double previousNumber = 0;
            auto conversionValues = getValues();
 
            // Iterate the std::string starting from the end
            for (int index = roman.length() - 1; index >= 0; --index) {
                // Get the current letter
                std::string currentLetter = std::string(1, roman[index]);
 
                // Skip whitepsace characters
                if (isEmpty(currentLetter)) {
                    continue;
                }
 
                // Find a conversion value that matches the current letter
                auto conversionValue = find(conversionValues, currentLetter);
 
                // If a valid conversion was found, get the value
                if (conversionValue.isEmpty()) {
                    continue;
                }
 
                auto currentNumber = conversionValue.decimal();
 
                // Calculate the result
                if (previousNumber > currentNumber) {
                    decimal -= currentNumber;
                } else {
                    decimal += currentNumber;
                }
 
                // Save the current number in order to process the next letter
                previousNumber = currentNumber;
            }
        }
 
        return decimal;
    }
 
    // Returns roman Numeral Conversion Values
    static std::vector<RomanNumeral> getValues() {
        std::vector<RomanNumeral> conversionValues;
 
        conversionValues.push_back(RomanNumeral(1000, "M"));
        conversionValues.push_back(RomanNumeral(900, "CM"));
        conversionValues.push_back(RomanNumeral(500, "D"));
        conversionValues.push_back(RomanNumeral(400, "CD"));
        conversionValues.push_back(RomanNumeral(100, "C"));
        conversionValues.push_back(RomanNumeral(90, "XC"));
        conversionValues.push_back(RomanNumeral(50, "L"));
        conversionValues.push_back(RomanNumeral(40, "XL"));
        conversionValues.push_back(RomanNumeral(10, "X"));
        conversionValues.push_back(RomanNumeral(9, "IX"));
        conversionValues.push_back(RomanNumeral(5, "V"));
        conversionValues.push_back(RomanNumeral(4, "IV"));
        conversionValues.push_back(RomanNumeral(1, "I"));
 
        // Sort the list in descending roman numeral order
        std::sort(conversionValues.begin(), conversionValues.end(), [](const auto& lhs, const auto& rhs) {
            return lhs.decimal() > rhs.decimal();
        });
 
        return conversionValues;
    }
 
    // Finds a conversion that matches the given roman numeral search value
    static RomanNumeral find(std::vector<RomanNumeral> conversionValues, std::string searchValue) {
        RomanNumeral result;
 
        searchValue = toLower(searchValue);
        auto predicate = [searchValue](auto x) { return (toLower(x.roman()) == searchValue); };
        auto iter = std::find_if(conversionValues.begin(), conversionValues.end(), predicate);
        if (iter != conversionValues.end()) {
            result = *iter;
        }
        return result;
    }
 
    // Checks if a string is empty or only contains whitespace
    static bool isEmpty(std::string str) {
        return str.empty()
            || std::all_of(str.begin(), str.end(), [](char c) {
                return std::isspace(static_cast<unsigned char>(c));
            });
    }
 
    // Converts a string to lowercase
    static std::string toLower(std::string str) {
        std::transform(str.begin(), str.end(), str.begin(),
            [](char c) { return std::tolower(static_cast<unsigned char>(c)); });
        return str;
    }
};
 
void display(std::string message) {
    message += "\n";
    std::cout << message;
}
 
void romanTest(std::string roman) {
    auto decimal = RomanNumeral::convertToDecimal(roman);
    auto convertedBack = RomanNumeral::convertToRoman(decimal);
 
    display("======= Roman Test Start =======");
 
    display("Original = " + roman
        + "\n Converted = " + std::to_string(decimal)
        + "\n Converted Back To Original = " + convertedBack);
 
    display("======= Roman Test End =======");
}
 
void decimalTest(double decimal) {
    auto roman = RomanNumeral::convertToRoman(decimal);
    auto convertedBack = RomanNumeral::convertToDecimal(roman);
 
    display("======= Decimal Test Start =======");
 
    display("Original = " + std::to_string(decimal)
        + "\n Converted = " + roman 
        + "\n Converted Back To Original = " + std::to_string(convertedBack));
 
    display("======= Decimal Test End =======");
}
 
int main() {
    auto decimal = 1987;
    decimalTest(decimal);
 
    display("");
 
    auto roman = "McMxcI";
    romanTest(roman);
 
    std::cin.get();
    return 0;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output

======= Decimal Test Start ======= Original = 1987.000000 Converted = MCMLXXXVII Converted Back To Original = 1987.000000 ======= Decimal Test End =======
======= Roman Test Start ======= Original = McMxcI Converted = 1991.000000 Converted Back To Original = MCMXCI ======= Roman Test End =======

C++ || Telephone Digit Program – How To Convert Letters To Numbers Using C++

November 01, 2020 admin No comments

The following is a program with functions which demonstrates how to implement a telephone digit program which converts the letters on a phone number keypad to digits.

The program allows to convert more than one letter at a time, include a hyphen, and allows both upper and lower case.

For example, the input text of “get loan”, the output would be:

438-5626

1. Telephone Digit Program

The example below demonstrates how to convert letters to numbers.





		
		
			1. Telephone Digit Program
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Nov 1, 2020
//    Taken From: http://programmingnotes.org/
//    File:  telephone.cpp
//    Description: Converts letters to digits in a telephone number
// ============================================================================
#include <iostream>
#include <string>
#include <map>
#include <cctype>
#include <exception>
#include <stdexcept>
#include <algorithm>

std::string convertNumber(std::string phoneNumber) {
    // Remove whitespace from string
    phoneNumber.erase(std::remove_if(phoneNumber.begin(), phoneNumber.end(), [](char c) {
        return std::isspace(static_cast<unsigned char>(c));
    }), phoneNumber.end());

    // Check if string is valid
    if (phoneNumber.length() < 1 || phoneNumber.length() > 10) {
        throw std::invalid_argument {phoneNumber + " is not a valid phone number"};
    }

    const std::string keypad = "22233344455566677778889999";
    std::map<char, char> alphabet;

    // Build the phone number mapping alphabet
    for (unsigned index = 0; index < keypad.length(); ++index) {
        alphabet['a' + index] = alphabet['A' + index] = keypad[index];
    }

    // Convert the letters to numbers
    std::string result = "";
    for (const auto& ch : phoneNumber) {
        auto number = ch;
        if (!std::isdigit(number)) {
            auto search = alphabet.find(number);
            if (search == alphabet.end()) {
                // Invalid input
                continue;
            }
            number = search->second;
        }
        result += number;
    }

    // Add the hyphens if necessary
    if (result.length() > 9) {
        result.insert(result.length() - 4, "-");
    } 
    if (result.length() > 3) {
        result.insert(3, "-");
    }

    return result;
}

int main() {
    std::cout << "This is a program to convert letters to"
        << " their corresponding telephone digits." 
        << std::endl << std::endl
        << "Enter your letters: ";

    std::string phoneNumber = "";
    std::getline(std::cin, phoneNumber);

    try {
        std::cout << "\nThe number converted: "
            << convertNumber(phoneNumber) << std::endl;
    } catch (std::exception& e) {
        std::cout << "\nAn error occurred: " << e.what();
    }

    std::cin.get();
    return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Nov 1, 2020
//    Taken From: http://programmingnotes.org/
//    File:  telephone.cpp
//    Description: Converts letters to digits in a telephone number
// ============================================================================
#include <iostream>
#include <string>
#include <map>
#include <cctype>
#include <exception>
#include <stdexcept>
#include <algorithm>
 
std::string convertNumber(std::string phoneNumber) {
    // Remove whitespace from string
    phoneNumber.erase(std::remove_if(phoneNumber.begin(), phoneNumber.end(), [](char c) {
        return std::isspace(static_cast<unsigned char>(c));
    }), phoneNumber.end());
 
    // Check if string is valid
    if (phoneNumber.length() < 1 || phoneNumber.length() > 10) {
        throw std::invalid_argument {phoneNumber + " is not a valid phone number"};
    }
 
    const std::string keypad = "22233344455566677778889999";
    std::map<char, char> alphabet;
 
    // Build the phone number mapping alphabet
    for (unsigned index = 0; index < keypad.length(); ++index) {
        alphabet['a' + index] = alphabet['A' + index] = keypad[index];
    }
 
    // Convert the letters to numbers
    std::string result = "";
    for (const auto& ch : phoneNumber) {
        auto number = ch;
        if (!std::isdigit(number)) {
            auto search = alphabet.find(number);
            if (search == alphabet.end()) {
                // Invalid input
                continue;
            }
            number = search->second;
        }
        result += number;
    }
 
    // Add the hyphens if necessary
    if (result.length() > 9) {
        result.insert(result.length() - 4, "-");
    } 
    if (result.length() > 3) {
        result.insert(3, "-");
    }
 
    return result;
}
 
int main() {
    std::cout << "This is a program to convert letters to"
        << " their corresponding telephone digits." 
        << std::endl << std::endl
        << "Enter your letters: ";
 
    std::string phoneNumber = "";
    std::getline(std::cin, phoneNumber);
 
    try {
        std::cout << "\nThe number converted: "
            << convertNumber(phoneNumber) << std::endl;
    } catch (std::exception& e) {
        std::cout << "\nAn error occurred: " << e.what();
    }
 
    std::cin.get();
    return 0;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output
(Note: the code was compiled separate times to display different output)

====== RUN 1 ======
This is a program to convert letters to their corresponding telephone digits. Enter your letters: get loan The number converted: 438-5626 ====== RUN 2 ====== This is a program to convert letters to their corresponding telephone digits. Enter your letters: getloan The number converted: 438-5626 ====== RUN 3 ====== This is a program to convert letters to their corresponding telephone digits. Enter your letters: get-loan The number converted: 438-5626 ====== RUN 4 ====== This is a program to convert letters to their corresponding telephone digits. Enter your letters: GETLOAN The number converted: 438-5626 ====== RUN 5 ====== This is a program to convert letters to their corresponding telephone digits. Enter your letters: G e T L O a N The number converted: 438-5626 ====== RUN 6 ====== This is a program to convert letters to their corresponding telephone digits. Enter your letters: 6572782011 The number converted: 657-278-2011

C++ || How To Find All Combinations Of Well-Formed Brackets Using C++

October 07, 2020 admin No comments

The following is a program with functions which demonstrates how to find all combinations of well-formed brackets.

The task is to write a function Brackets(int n) that prints all combinations of well-formed brackets from 1…n. For example, Brackets(3), the output would be:

() (()) ()() ((())) (()()) (())() ()(()) ()()()

The number of possible combinations is the Catalan number of N pairs C(n).

1. Find All Well-Formed Brackets

The example below demonstrates the use of the ‘brackets‘ function to find all the well-formed bracket combinations.





		
		
			1. Find All Well-Formed Brackets
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Oct 7, 2020
//    Taken From: http://programmingnotes.org/
//    File:  generateParenthesis.cpp
//    Description: Generate all combinations of well-formed brackets from 1…n
// ============================================================================
#include <iostream>
#include <vector>
#include <string>

struct result {
    int pair;
    std::string combination;
};

struct symbols {
    std::string open;
    std::string close;
};

std::string buildBrackets(std::string output, int open, int close, int pair, symbols symbols) {
    if ((open == pair) && (close == pair)) {
        return output;
    }
    std::string result = "";
    if (open < pair) {
        std::string openCombo = buildBrackets(output + symbols.open, open + 1, close, pair, symbols);
        if (openCombo.length() > 0) {
            result += (result.length() > 0 ? ", " : "") + openCombo;
        }
    }
    if (close < open) {
        std::string closeCombo = buildBrackets(output + symbols.close, open, close + 1, pair, symbols);
        if (closeCombo.length() > 0) {
            result += (result.length() > 0 ? ", " : "") + closeCombo;
        }
    }
    return result;
}

/**
* FUNCTION: brackets
* USE: Returns all combinations of well-formed brackets from 1...n
* @param pairs: The number of bracket combinations to generate.
* @param open: Optional. The 'open bracket' symbol.
* @param close: Optional. The 'close bracket' symbol.
* @return: An array of bracket combination info.
*/
std::vector<result> brackets(int pairs, std::string open = "(", std::string close = ")") {
    std::vector<result> results;
    symbols symbols{open, close};

    for (int pair = 1; pair <= pairs; ++pair) {
        result result{pair, buildBrackets("", 0, 0, pair, symbols)};
        results.push_back(result);
    }
    return results;
}

int main() {
    std::vector<result> results = brackets(4);
    for (auto const &result : results) {
        std::cout << "Pair: " << result.pair << ", Combination: " << result.combination << std::endl;
    }
    std::cin.get();
    return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Oct 7, 2020
//    Taken From: http://programmingnotes.org/
//    File:  generateParenthesis.cpp
//    Description: Generate all combinations of well-formed brackets from 1…n
// ============================================================================
#include <iostream>
#include <vector>
#include <string>
 
struct result {
    int pair;
    std::string combination;
};
 
struct symbols {
    std::string open;
    std::string close;
};
 
std::string buildBrackets(std::string output, int open, int close, int pair, symbols symbols) {
    if ((open == pair) && (close == pair)) {
        return output;
    }
    std::string result = "";
    if (open < pair) {
        std::string openCombo = buildBrackets(output + symbols.open, open + 1, close, pair, symbols);
        if (openCombo.length() > 0) {
            result += (result.length() > 0 ? ", " : "") + openCombo;
        }
    }
    if (close < open) {
        std::string closeCombo = buildBrackets(output + symbols.close, open, close + 1, pair, symbols);
        if (closeCombo.length() > 0) {
            result += (result.length() > 0 ? ", " : "") + closeCombo;
        }
    }
    return result;
}
 
/**
* FUNCTION: brackets
* USE: Returns all combinations of well-formed brackets from 1...n
* @param pairs: The number of bracket combinations to generate.
* @param open: Optional. The 'open bracket' symbol.
* @param close: Optional. The 'close bracket' symbol.
* @return: An array of bracket combination info.
*/
std::vector<result> brackets(int pairs, std::string open = "(", std::string close = ")") {
    std::vector<result> results;
    symbols symbols{open, close};
 
    for (int pair = 1; pair <= pairs; ++pair) {
        result result{pair, buildBrackets("", 0, 0, pair, symbols)};
        results.push_back(result);
    }
    return results;
}
 
int main() {
    std::vector<result> results = brackets(4);
    for (auto const &result : results) {
        std::cout << "Pair: " << result.pair << ", Combination: " << result.combination << std::endl;
    }
    std::cin.get();
    return 0;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output

Pair: 1, Combination: () Pair: 2, Combination: (()), ()() Pair: 3, Combination: ((())), (()()), (())(), ()(()), ()()() Pair: 4, Combination: (((()))), ((()())), ((())()), ((()))(), (()(())), (()()()), (()())(), (())(()), (())()(), ()((())), ()(()()), ()(())(), ()()(()), ()()()()

C++ || Multi Digit, Decimal & Negative Number Infix To Postfix Conversion & Evaluation

January 31, 2014 admin 1 Comment

Click Here For Updated Version Of Program

The following is sample code which demonstrates the implementation of a multi digit, decimal, and negative number infix to postfix converter and evaluator using a Finite State Machine

REQUIRED KNOWLEDGE FOR THIS PROGRAM

How To Convert Infix To Postfix How To Evaluate A Postfix Expression What Is A Finite State Machine?

Using a Finite State Machine, the program demonstrated on this page has the ability to convert and evaluate a single digit, multi digit, decimal number, and/or negative number infix equation. So for example, if the the infix equation of (19.87 * -2) was entered into the program, the converted postfix expression of 19.87 ~2* would display to the screen, as well as the final evaluated answer of -39.74.

NOTE: In this program, negative numbers are represented by the “~” symbol on the postfix string. This is used to differentiate between a negative number and a subtraction symbol.

This program has the following flow of control:

• Get an infix expression from the user • Convert the infix expression to postfix • Use a Finite State Machine to isolate all of the math operators, multi digit, decimal, negative and single digit numbers that are found in the postfix expression • Evaluate the postfix expression using the tokens found from the above step • Display the evaluated answer to the screen

The above steps are implemented below.





		
		
			Multi Digit Infix To Postfix Conversion & Evaluation
			
C++
			
			// ============================================================================
//   Author:  Kenneth Perkins
//   Taken From: http://programmingnotes.org/
//   Date:  Jan 31, 2014
//   File: InToPostEval.cpp
//   Description: The following demonstrates the implementation of an infix to
//     postfix converter and evaluator. Using a Finite State Machine, this
//     program has the ability to convert and evaluate multi digit, decimal,
//     negative and positive values.
// ============================================================================
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <string>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;

/* This holds the transition states for our Finite State Machine
    -- They are placed in numerical order for easy understanding within
        the FSM array, which is located below */

enum FSM_TRANSITIONS
{
    REJECT = 0,
    INTEGER,
    REAL,
    NEGATIVE,
    OPERATOR,
    UNKNOWN,
    SPACE
};

/* This is the Finite State Machine
    -- The zero represents a place holder, so the row in the array
            starts on row 1 instead of 0

                           integer,  real,  negative, operator, unknown, space */
int stateTable[][7] = { {0, INTEGER,  REAL, NEGATIVE, OPERATOR,  UNKNOWN,  SPACE},
/* STATE 1 */   {INTEGER,  INTEGER,  REAL,   REJECT,  REJECT,   REJECT,  REJECT},
/* STATE 2 */   {REAL,       REAL,  REJECT,  REJECT,  REJECT,   REJECT,  REJECT},
/* STATE 3 */   {NEGATIVE, INTEGER,  REAL,   REJECT,  REJECT,   REJECT,  REJECT},
/* STATE 4 */   {OPERATOR,  REJECT, REJECT,  REJECT,  REJECT,   REJECT,  REJECT},
/* STATE 5 */   {UNKNOWN,   REJECT, REJECT,  REJECT,  REJECT,   UNKNOWN, REJECT},
/* STATE 6 */   {SPACE,     REJECT, REJECT,  REJECT,  REJECT,   REJECT,  REJECT} };

// function prototypes
void DisplayDirections();
string ConvertInfixToPostfix(string infix);
bool IsMathOperator(char token);
int OrderOfOperations(char token);
vector<string> Lexer(string postfix);
int Get_FSM_Col(char& currentChar);
double EvaluatePostfix(const vector<string>& postfix);
double Calculate(char token, double op1, double op2);

int main()
{
    // declare variables
    string infix = "";
    string postfix = "";
    double answer = 0;
    vector<string> tokens;

    // display directions to user
    DisplayDirections();

    // get data from user
    cout << "\nPlease enter an Infix expression: ";
    getline(cin, infix);

    postfix = ConvertInfixToPostfix(infix);

    // use the "Lexer" function to isolate multi digit, negative and decimal
    // numbers, aswell as single digit numbers and math operators
    tokens = Lexer(postfix);

    // display the found tokens to the screen
    //for (unsigned x = 0; x < tokens.size(); ++x)
    //{
    //    cout<<tokens.at(x)<<endl;
    //}

    cout << "\nThe Infix expression = " << infix;
    cout << "\nThe Postfix expression = " << postfix << endl;

    answer = EvaluatePostfix(tokens);

    cout << "\nFinal answer = " << answer << endl;

    cin.get();
    return 0;
}// end of main

void DisplayDirections()
{// this function displays instructions to the screen
    cout << "\n==== Infix To Postfix Conversion & Evaluation ====\n"
        << "\nMath Operators:\n"
        << "+ || Addition\n"
        << "- || Subtraction\n"
        << "* || Multiplication\n"
        << "/ || Division\n"
        << "% || Modulus\n"
        << "^ || Power\n"
        << "$ || Square Root\n"
        << "s || Sine\n"
        << "c || Cosine\n"
        << "t || Tangent\n"
        << "- || Negative Number\n"
        << "Sample Infix Equation: ((s(-4^5)*1.4)/($(23+2)--2.8))*(c(1%2)/(7.28*.1987)^(t23))\n";
    // ((sin(-4^5)*1.4)/(sqrt(23+2)--2.8))*(cos(1%2)/(7.28*.1987)^(tan(23)))
}// end of DisplayDirections

string ConvertInfixToPostfix(string infix)
{// this function converts an infix expression to postfix
    // declare function variables
    string postfix;
    stack<char> charStack;

    // remove all whitespace from the string
    infix.erase(std::remove_if(infix.begin(), infix.end(), [](char c) {
        return std::isspace(static_cast<unsigned char>(c));
    }), infix.end());

    // automatically convert negative numbers to have the ~ symbol
    for (unsigned x = 0; x < infix.length(); ++x) {
        if (infix[x] != '-') {
            continue;
        } else if (x + 1 < infix.length() && IsMathOperator(infix[x + 1])) {
            continue;
        }
        if (x == 0 || infix[x - 1] == '(' || IsMathOperator(infix[x - 1])) {
            infix[x] = '~';
        }
    }

    // loop thru array until there is no more data
    for (unsigned x = 0; x < infix.length(); ++x)
    {
        // place numbers (standard, decimal, & negative)
        // numbers onto the 'postfix' string
        if ((isdigit(infix[x])) || (infix[x] == '.') || (infix[x] == '~'))
        {
            postfix += infix[x];
        }
        else if (isspace(infix[x]))
        {
            continue;
        }
        else if (IsMathOperator(infix[x]))
        {
            postfix += " ";
            // use the 'OrderOfOperations' function to check equality
            // of the math operator at the top of the stack compared to
            // the current math operator in the infix string
            while ((!charStack.empty()) &&
                (OrderOfOperations(charStack.top()) >= OrderOfOperations(infix[x])))
            {
                // place the math operator from the top of the
                // stack onto the postfix string and continue the
                // process until complete
                postfix += charStack.top();
                charStack.pop();
            }
            // push the remaining math operator onto the stack
            charStack.push(infix[x]);
        }
        // push outer parentheses onto stack
        else if (infix[x] == '(')
        {
            charStack.push(infix[x]);
        }
        else if (infix[x] == ')')
        {
            // pop the current math operator from the stack
            while ((!charStack.empty()) && (charStack.top() != '('))
            {
                // place the math operator onto the postfix string
                postfix += charStack.top();
                // pop the next operator from the stack and
                // continue the process until complete
                charStack.pop();
            }

            if (!charStack.empty()) // pop '(' symbol off the stack
            {
                charStack.pop();
            }
            else // no matching '('
            {
                cout << "\nPARENTHESES MISMATCH #1\n";
                exit(1);
            }
        }
        else
        {
            cout << "\nINVALID INPUT #1\n";
            exit(1);
        }
    }

    // place any remaining math operators from the stack onto
    // the postfix array
    while (!charStack.empty())
    {
        postfix += charStack.top();
        charStack.pop();
    }

    return postfix;
}// end of ConvertInfixToPostfix

bool IsMathOperator(char token)
{// this function checks if operand is a math operator
    switch (tolower(token))
    {
    case '+': case '-': case '*': case '/':
    case '%': case '^': case '$': case 'c':
    case 's': case 't':
        return true;
        break;
    default:
        return false;
        break;
    }
}// end of IsMathOperator

int OrderOfOperations(char token)
{// this function returns the priority of each math operator
    int priority = 0;
    switch (tolower(token))
    {
    case 'c': case 's': case 't':
        priority = 5;
        break;
    case '^': case '$':
        priority = 4;
        break;
    case '*': case '/': case '%':
        priority = 3;
        break;
    case '-':
        priority = 2;
        break;
    case '+':
        priority = 1;
        break;
    }
    return priority;
}// end of OrderOfOperations

vector<string> Lexer(string postfix)
{// this function parses a postfix string using an FSM to generate
 //  each individual token in the expression
    vector<string> tokens;
    char currentChar = ' ';
    int col = REJECT;
    int currentState = REJECT;
    string currentToken = "";

    // use an FSM to parse multidigit and decimal numbers
    // also does error check for invalid input of decimals
    for (unsigned x = 0; x < postfix.length();)
    {
        currentChar = postfix[x];

        // get the column number for the current character
        col = Get_FSM_Col(currentChar);

        // exit if the real number has multiple periods "."
        // in the expression (i.e: 19.3427.23)
        if ((currentState == REAL) && (col == REAL))
        {
            cerr << "\nINVALID INPUT #2\n";
            exit(1);
        }
        /* ========================================================

            THIS IS WHERE WE CHECK THE FINITE STATE MACHINE TABLE
               USING THE "col" VARIABLE FROM ABOVE ^

          ========================================================= */

          // get the current state of our machine
        currentState = stateTable[currentState][col];

        /* ===================================================

          THIS IS WHERE WE CHECK FOR A SUCCESSFUL PARSE
           - If the current state in our machine == REJECT
             (the starting state), then we have successfully parsed
             a token, which is returned to its caller

            - ELSE we continue trying to find a successful token

            =================================================== */
        if (currentState == REJECT)
        {
            if (currentToken != " ") // we dont care about whitespace
            {
                tokens.push_back(currentToken);
            }
            currentToken = "";
        }
        else
        {
            currentToken += currentChar;
            ++x;
        }

    }
    // this ensures the last token gets saved when
    // we reach the end of the postfix string buffer
    if (currentToken != " ") // we dont care about whitespace
    {
        tokens.push_back(currentToken);
    }
    return tokens;
}// end of Lexer

int Get_FSM_Col(char& currentChar)
{// this function determines the state of the type of character being examined
    // check for whitespace
    if (isspace(currentChar))
    {
        return SPACE;
    }

    // check for integer numbers
    else if (isdigit(currentChar))
    {
        return INTEGER;
    }

    // check for real numbers
    else if (currentChar == '.')
    {
        return REAL;
    }

    // check for negative numbers
    else if (currentChar == '~')
    {
        currentChar = '-';
        return NEGATIVE;
    }

    // check for math operators
    else if (IsMathOperator(currentChar))
    {
        return OPERATOR;
    }
    return UNKNOWN;
}// end of Get_FSM_Col

double EvaluatePostfix(const vector<string>& postfix)
{// this function evaluates a postfix expression
    // declare function variables
    double op1 = 0;
    double op2 = 0;
    double answer = 0;
    stack<double> doubleStack;

    cout << "\nCalculations:\n";

    // loop thru array until there is no more data
    for (unsigned x = 0; x < postfix.size(); ++x)
    {
        // push numbers onto the stack
        if ((isdigit(postfix[x][0])) || (postfix[x][0] == '.'))
        {
            doubleStack.push(atof(postfix[x].c_str()));
        }
        // push negative numbers onto the stack
        else if ((postfix[x].length() > 1) && ((postfix[x][0] == '-') &&
            (isdigit(postfix[x][1]) || (postfix[x][1] == '.'))))
        {
            doubleStack.push(atof(postfix[x].c_str()));
        }
        // if expression is a math operator, pop numbers from stack
        // & send the popped numbers to the 'Calculate' function
        else if (IsMathOperator(postfix[x][0]) && (!doubleStack.empty()))
        {
            char token = tolower(postfix[x][0]);

            // if expression is square root, sin, cos,
            // or tan operation only pop stack once
            if (token == '$' || token == 's' || token == 'c' || token == 't')
            {
                op2 = 0;
                op1 = doubleStack.top();
                doubleStack.pop();
                answer = Calculate(token, op1, op2);
                doubleStack.push(answer);
            }
            else if (doubleStack.size() > 1)
            {
                op2 = doubleStack.top();
                doubleStack.pop();
                op1 = doubleStack.top();
                doubleStack.pop();
                answer = Calculate(token, op1, op2);
                doubleStack.push(answer);
            }
        }
        else // this should never execute, & if it does, something went really wrong
        {
            cout << "\nINVALID INPUT #3\n";
            exit(1);
        }
    }
    // pop the final answer from the stack, and return to main
    if (!doubleStack.empty())
    {
        answer = doubleStack.top();
    }
    return answer;
}// end of EvaluatePostfix

double Calculate(char token, double op1, double op2)
{// this function carries out the actual math process
    double ans = 0;
    switch (tolower(token))
    {
    case '+':
        cout << op1 << token << op2 << " = ";
        ans = op1 + op2;
        break;
    case '-':
        cout << op1 << token << op2 << " = ";
        ans = op1 - op2;
        break;
    case '*':
        cout << op1 << token << op2 << " = ";
        ans = op1 * op2;
        break;
    case '/':
        cout << op1 << token << op2 << " = ";
        ans = op1 / op2;
        break;
    case '%':
        cout << op1 << token << op2 << " = ";
        ans = ((int)op1 % (int)op2) + modf(op1, &op2);
        break;
    case '^':
        cout << op1 << token << op2 << " = ";
        ans = pow(op1, op2);
        break;
    case '$':
        cout << char(251) << op1 << " = ";
        ans = sqrt(op1);
        break;
    case 'c':
        cout << "cos(" << op1 << ") = ";
        ans = cos(op1);
        break;
    case 's':
        cout << "sin(" << op1 << ") = ";
        ans = sin(op1);
        break;
    case 't':
        cout << "tan(" << op1 << ") = ";
        ans = tan(op1);
        break;
    default:
        ans = 0;
        break;
    }
    cout << ans << endl;
    return ans;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
				
						// ============================================================================
//   Author:  Kenneth Perkins
//   Taken From: http://programmingnotes.org/
//   Date:  Jan 31, 2014
//   File: InToPostEval.cpp
//   Description: The following demonstrates the implementation of an infix to
//     postfix converter and evaluator. Using a Finite State Machine, this
//     program has the ability to convert and evaluate multi digit, decimal,
//     negative and positive values.
// ============================================================================
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <string>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;
 
/* This holds the transition states for our Finite State Machine
    -- They are placed in numerical order for easy understanding within
        the FSM array, which is located below */
 
enum FSM_TRANSITIONS
{
    REJECT = 0,
    INTEGER,
    REAL,
    NEGATIVE,
    OPERATOR,
    UNKNOWN,
    SPACE
};
 
/* This is the Finite State Machine
    -- The zero represents a place holder, so the row in the array
            starts on row 1 instead of 0
 
                           integer,  real,  negative, operator, unknown, space */
int stateTable[][7] = { {0, INTEGER,  REAL, NEGATIVE, OPERATOR,  UNKNOWN,  SPACE},
/* STATE 1 */   {INTEGER,  INTEGER,  REAL,   REJECT,  REJECT,   REJECT,  REJECT},
/* STATE 2 */   {REAL,       REAL,  REJECT,  REJECT,  REJECT,   REJECT,  REJECT},
/* STATE 3 */   {NEGATIVE, INTEGER,  REAL,   REJECT,  REJECT,   REJECT,  REJECT},
/* STATE 4 */   {OPERATOR,  REJECT, REJECT,  REJECT,  REJECT,   REJECT,  REJECT},
/* STATE 5 */   {UNKNOWN,   REJECT, REJECT,  REJECT,  REJECT,   UNKNOWN, REJECT},
/* STATE 6 */   {SPACE,     REJECT, REJECT,  REJECT,  REJECT,   REJECT,  REJECT} };
 
// function prototypes
void DisplayDirections();
string ConvertInfixToPostfix(string infix);
bool IsMathOperator(char token);
int OrderOfOperations(char token);
vector<string> Lexer(string postfix);
int Get_FSM_Col(char& currentChar);
double EvaluatePostfix(const vector<string>& postfix);
double Calculate(char token, double op1, double op2);
 
int main()
{
    // declare variables
    string infix = "";
    string postfix = "";
    double answer = 0;
    vector<string> tokens;
 
    // display directions to user
    DisplayDirections();
 
    // get data from user
    cout << "\nPlease enter an Infix expression: ";
    getline(cin, infix);
 
    postfix = ConvertInfixToPostfix(infix);
 
    // use the "Lexer" function to isolate multi digit, negative and decimal
    // numbers, aswell as single digit numbers and math operators
    tokens = Lexer(postfix);
 
    // display the found tokens to the screen
    //for (unsigned x = 0; x < tokens.size(); ++x)
    //{
    //    cout<<tokens.at(x)<<endl;
    //}
 
    cout << "\nThe Infix expression = " << infix;
    cout << "\nThe Postfix expression = " << postfix << endl;
 
    answer = EvaluatePostfix(tokens);
 
    cout << "\nFinal answer = " << answer << endl;
 
    cin.get();
    return 0;
}// end of main
 
void DisplayDirections()
{// this function displays instructions to the screen
    cout << "\n==== Infix To Postfix Conversion & Evaluation ====\n"
        << "\nMath Operators:\n"
        << "+ || Addition\n"
        << "- || Subtraction\n"
        << "* || Multiplication\n"
        << "/ || Division\n"
        << "% || Modulus\n"
        << "^ || Power\n"
        << "$ || Square Root\n"
        << "s || Sine\n"
        << "c || Cosine\n"
        << "t || Tangent\n"
        << "- || Negative Number\n"
        << "Sample Infix Equation: ((s(-4^5)*1.4)/($(23+2)--2.8))*(c(1%2)/(7.28*.1987)^(t23))\n";
    // ((sin(-4^5)*1.4)/(sqrt(23+2)--2.8))*(cos(1%2)/(7.28*.1987)^(tan(23)))
}// end of DisplayDirections
 
string ConvertInfixToPostfix(string infix)
{// this function converts an infix expression to postfix
    // declare function variables
    string postfix;
    stack<char> charStack;
 
    // remove all whitespace from the string
    infix.erase(std::remove_if(infix.begin(), infix.end(), [](char c) {
        return std::isspace(static_cast<unsigned char>(c));
    }), infix.end());
 
    // automatically convert negative numbers to have the ~ symbol
    for (unsigned x = 0; x < infix.length(); ++x) {
        if (infix[x] != '-') {
            continue;
        } else if (x + 1 < infix.length() && IsMathOperator(infix[x + 1])) {
            continue;
        }
        if (x == 0 || infix[x - 1] == '(' || IsMathOperator(infix[x - 1])) {
            infix[x] = '~';
        }
    }
 
    // loop thru array until there is no more data
    for (unsigned x = 0; x < infix.length(); ++x)
    {
        // place numbers (standard, decimal, & negative)
        // numbers onto the 'postfix' string
        if ((isdigit(infix[x])) || (infix[x] == '.') || (infix[x] == '~'))
        {
            postfix += infix[x];
        }
        else if (isspace(infix[x]))
        {
            continue;
        }
        else if (IsMathOperator(infix[x]))
        {
            postfix += " ";
            // use the 'OrderOfOperations' function to check equality
            // of the math operator at the top of the stack compared to
            // the current math operator in the infix string
            while ((!charStack.empty()) &&
                (OrderOfOperations(charStack.top()) >= OrderOfOperations(infix[x])))
            {
                // place the math operator from the top of the
                // stack onto the postfix string and continue the
                // process until complete
                postfix += charStack.top();
                charStack.pop();
            }
            // push the remaining math operator onto the stack
            charStack.push(infix[x]);
        }
        // push outer parentheses onto stack
        else if (infix[x] == '(')
        {
            charStack.push(infix[x]);
        }
        else if (infix[x] == ')')
        {
            // pop the current math operator from the stack
            while ((!charStack.empty()) && (charStack.top() != '('))
            {
                // place the math operator onto the postfix string
                postfix += charStack.top();
                // pop the next operator from the stack and
                // continue the process until complete
                charStack.pop();
            }
 
            if (!charStack.empty()) // pop '(' symbol off the stack
            {
                charStack.pop();
            }
            else // no matching '('
            {
                cout << "\nPARENTHESES MISMATCH #1\n";
                exit(1);
            }
        }
        else
        {
            cout << "\nINVALID INPUT #1\n";
            exit(1);
        }
    }
 
    // place any remaining math operators from the stack onto
    // the postfix array
    while (!charStack.empty())
    {
        postfix += charStack.top();
        charStack.pop();
    }
 
    return postfix;
}// end of ConvertInfixToPostfix
 
bool IsMathOperator(char token)
{// this function checks if operand is a math operator
    switch (tolower(token))
    {
    case '+': case '-': case '*': case '/':
    case '%': case '^': case '$': case 'c':
    case 's': case 't':
        return true;
        break;
    default:
        return false;
        break;
    }
}// end of IsMathOperator
 
int OrderOfOperations(char token)
{// this function returns the priority of each math operator
    int priority = 0;
    switch (tolower(token))
    {
    case 'c': case 's': case 't':
        priority = 5;
        break;
    case '^': case '$':
        priority = 4;
        break;
    case '*': case '/': case '%':
        priority = 3;
        break;
    case '-':
        priority = 2;
        break;
    case '+':
        priority = 1;
        break;
    }
    return priority;
}// end of OrderOfOperations
 
vector<string> Lexer(string postfix)
{// this function parses a postfix string using an FSM to generate
 //  each individual token in the expression
    vector<string> tokens;
    char currentChar = ' ';
    int col = REJECT;
    int currentState = REJECT;
    string currentToken = "";
 
    // use an FSM to parse multidigit and decimal numbers
    // also does error check for invalid input of decimals
    for (unsigned x = 0; x < postfix.length();)
    {
        currentChar = postfix[x];
 
        // get the column number for the current character
        col = Get_FSM_Col(currentChar);
 
        // exit if the real number has multiple periods "."
        // in the expression (i.e: 19.3427.23)
        if ((currentState == REAL) && (col == REAL))
        {
            cerr << "\nINVALID INPUT #2\n";
            exit(1);
        }
        /* ========================================================
 
            THIS IS WHERE WE CHECK THE FINITE STATE MACHINE TABLE
               USING THE "col" VARIABLE FROM ABOVE ^
 
          ========================================================= */
 
          // get the current state of our machine
        currentState = stateTable[currentState][col];
 
        /* ===================================================
 
          THIS IS WHERE WE CHECK FOR A SUCCESSFUL PARSE
           - If the current state in our machine == REJECT
             (the starting state), then we have successfully parsed
             a token, which is returned to its caller
 
            - ELSE we continue trying to find a successful token
 
            =================================================== */
        if (currentState == REJECT)
        {
            if (currentToken != " ") // we dont care about whitespace
            {
                tokens.push_back(currentToken);
            }
            currentToken = "";
        }
        else
        {
            currentToken += currentChar;
            ++x;
        }
 
    }
    // this ensures the last token gets saved when
    // we reach the end of the postfix string buffer
    if (currentToken != " ") // we dont care about whitespace
    {
        tokens.push_back(currentToken);
    }
    return tokens;
}// end of Lexer
 
int Get_FSM_Col(char& currentChar)
{// this function determines the state of the type of character being examined
    // check for whitespace
    if (isspace(currentChar))
    {
        return SPACE;
    }
 
    // check for integer numbers
    else if (isdigit(currentChar))
    {
        return INTEGER;
    }
 
    // check for real numbers
    else if (currentChar == '.')
    {
        return REAL;
    }
 
    // check for negative numbers
    else if (currentChar == '~')
    {
        currentChar = '-';
        return NEGATIVE;
    }
 
    // check for math operators
    else if (IsMathOperator(currentChar))
    {
        return OPERATOR;
    }
    return UNKNOWN;
}// end of Get_FSM_Col
 
double EvaluatePostfix(const vector<string>& postfix)
{// this function evaluates a postfix expression
    // declare function variables
    double op1 = 0;
    double op2 = 0;
    double answer = 0;
    stack<double> doubleStack;
 
    cout << "\nCalculations:\n";
 
    // loop thru array until there is no more data
    for (unsigned x = 0; x < postfix.size(); ++x)
    {
        // push numbers onto the stack
        if ((isdigit(postfix[x][0])) || (postfix[x][0] == '.'))
        {
            doubleStack.push(atof(postfix[x].c_str()));
        }
        // push negative numbers onto the stack
        else if ((postfix[x].length() > 1) && ((postfix[x][0] == '-') &&
            (isdigit(postfix[x][1]) || (postfix[x][1] == '.'))))
        {
            doubleStack.push(atof(postfix[x].c_str()));
        }
        // if expression is a math operator, pop numbers from stack
        // & send the popped numbers to the 'Calculate' function
        else if (IsMathOperator(postfix[x][0]) && (!doubleStack.empty()))
        {
            char token = tolower(postfix[x][0]);
 
            // if expression is square root, sin, cos,
            // or tan operation only pop stack once
            if (token == '$' || token == 's' || token == 'c' || token == 't')
            {
                op2 = 0;
                op1 = doubleStack.top();
                doubleStack.pop();
                answer = Calculate(token, op1, op2);
                doubleStack.push(answer);
            }
            else if (doubleStack.size() > 1)
            {
                op2 = doubleStack.top();
                doubleStack.pop();
                op1 = doubleStack.top();
                doubleStack.pop();
                answer = Calculate(token, op1, op2);
                doubleStack.push(answer);
            }
        }
        else // this should never execute, & if it does, something went really wrong
        {
            cout << "\nINVALID INPUT #3\n";
            exit(1);
        }
    }
    // pop the final answer from the stack, and return to main
    if (!doubleStack.empty())
    {
        answer = doubleStack.top();
    }
    return answer;
}// end of EvaluatePostfix
 
double Calculate(char token, double op1, double op2)
{// this function carries out the actual math process
    double ans = 0;
    switch (tolower(token))
    {
    case '+':
        cout << op1 << token << op2 << " = ";
        ans = op1 + op2;
        break;
    case '-':
        cout << op1 << token << op2 << " = ";
        ans = op1 - op2;
        break;
    case '*':
        cout << op1 << token << op2 << " = ";
        ans = op1 * op2;
        break;
    case '/':
        cout << op1 << token << op2 << " = ";
        ans = op1 / op2;
        break;
    case '%':
        cout << op1 << token << op2 << " = ";
        ans = ((int)op1 % (int)op2) + modf(op1, &op2);
        break;
    case '^':
        cout << op1 << token << op2 << " = ";
        ans = pow(op1, op2);
        break;
    case '$':
        cout << char(251) << op1 << " = ";
        ans = sqrt(op1);
        break;
    case 'c':
        cout << "cos(" << op1 << ") = ";
        ans = cos(op1);
        break;
    case 's':
        cout << "sin(" << op1 << ") = ";
        ans = sin(op1);
        break;
    case 't':
        cout << "tan(" << op1 << ") = ";
        ans = tan(op1);
        break;
    default:
        ans = 0;
        break;
    }
    cout << ans << endl;
    return ans;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

The following is sample output.

====== RUN 1 ====== ==== Infix To Postfix Conversion & Evaluation ====
Math Operators: + || Addition - || Subtraction * || Multiplication / || Division % || Modulus ^ || Power $ || Square Root s || Sine c || Cosine t || Tangent ~ || Negative Number Sample Infix Equation: ((s(~4^5)*1.4)/($(23+2)-~2.8))*(c(1%2)/(7.28*.1987)^(t23)) Please enter an Infix expression: 12/3*9 The Infix expression = 12/3*9 The Postfix expression = 12 3 /9* Calculations: 12/3 = 4 4*9 = 36 Final answer = 36 ====== RUN 2 ====== ==== Infix To Postfix Conversion & Evaluation ==== Math Operators: + || Addition - || Subtraction * || Multiplication / || Division % || Modulus ^ || Power $ || Square Root s || Sine c || Cosine t || Tangent ~ || Negative Number Sample Infix Equation: ((s(~4^5)*1.4)/($(23+2)-~2.8))*(c(1%2)/(7.28*.1987)^(t23)) Please enter an Infix expression: -150.89996 - 87.56643 The Infix expression = -150.89996 - 87.56643 The Postfix expression = ~150.89996 87.56643- Calculations: -150.9-87.5664 = -238.466 Final answer = -238.466 ====== RUN 3 ====== ==== Infix To Postfix Conversion & Evaluation ==== Math Operators: + || Addition - || Subtraction * || Multiplication / || Division % || Modulus ^ || Power $ || Square Root s || Sine c || Cosine t || Tangent ~ || Negative Number Sample Infix Equation: ((s(~4^5)*1.4)/($(23+2)-~2.8))*(c(1%2)/(7.28*.1987)^(t23)) Please enter an Infix expression: ((s(~4^5)*1.4)/($(23+2)-~2.8))*(c(1%2)/(7.28*.1987)^(t23)) The Infix expression = ((s(-4^5)*1.4)/($(23+2)--2.8))*(c(1%2)/(7.28*.1987)^(t23)) The Postfix expression = ~4 5^ s1.4* 23 2+ $~2.8-/ 1 2% c7.28 .1987* 23t^/* Calculations: -4^5 = -1024 sin(-1024) = 0.158533 0.158533*1.4 = 0.221947 23+2 = 25 √25 = 5 5--2.8 = 7.8 0.221947/7.8 = 0.0284547 1%2 = 1 cos(1) = 0.540302 7.28*0.1987 = 1.44654 tan(23) = 1.58815 1.44654^1.58815 = 1.79733 0.540302/1.79733 = 0.300614 0.0284547*0.300614 = 0.00855389 Final answer = 0.00855389 ====== RUN 4 ====== ==== Infix To Postfix Conversion & Evaluation ==== Math Operators: + || Addition - || Subtraction * || Multiplication / || Division % || Modulus ^ || Power $ || Square Root s || Sine c || Cosine t || Tangent - || Negative Number Sample Infix Equation: ((s(-4^5)*1.4)/($(23+2)--2.8))*(c(1%2)/(7.28*.1987)^(t23)) Please enter an Infix expression: (1987 + 1991) * -1 The Infix expression = (1987 + 1991) * -1 The Postfix expression = 1987 1991+ ~1* Calculations: 1987+1991 = 3978 3978*-1 = -3978 Final answer = -3978

C++ || Snippet – How To Override The Default Signal Handler (CTRL-C)

October 03, 2013 admin No comments

The following is sample code which demonstrates the use of the “signal” function call on Unix based systems.

Signals are interrupts delivered to a process by the operating system which can terminate a program prematurely. You can generate interrupts by pressing Ctrl+C. The “signal” function call receives two arguments. The first argument is an integer which represents the signal number, and the second argument is a pointer to the user defined signal handling function.

The following program catches the “SIGINT” signal number using the signal() function.





		
		
			How To Override CTRL-C
			
C++
			
			// ============================================================================
//    Author: K Perkins
//    Date:   Oct 3, 2013
//    Taken From: http://programmingnotes.org/
//    File:  Signal.cpp
//    Description: Demonstrate the use of overriding the default signal 
//       handler for the case when the user presses Ctrl-C. Test it by 
//       running and pressing Ctrl-C
// ============================================================================
#include <iostream>
#include <csignal>
#include <unistd.h>
using namespace std;

// function prototype
void SignalHandlerFunc(int arg);

// global variable
int count = 10;

int main()
{
    // overide the default signal handler (CTRL-C)
    // with our own "SignalHandlerFunc" function
    signal(SIGINT, SignalHandlerFunc);

    cerr<<"nPlease press CTRL-Cnn";

    // loop until condition is met
    do{
        sleep(1);
    }while(count > 0);

    // press ENTER on the keyboard to end
    // the program once all "lives" are lost
    cin.get();

    return 0;
}// end of main

/**
 * This function handles the signal
 * @param arg - the signal number
 */
void SignalHandlerFunc(int arg)
{
    // display text when user presses CTRL-C
    if(count > 0)
    {
        cerr<<" Haha I have "<<count<<" lives!n";
    }
    else
    {
        cerr<<" ** Ahh you got me...n";
    }
    --count;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
				
						// ============================================================================
//    Author: K Perkins
//    Date:   Oct 3, 2013
//    Taken From: http://programmingnotes.org/
//    File:  Signal.cpp
//    Description: Demonstrate the use of overriding the default signal 
//       handler for the case when the user presses Ctrl-C. Test it by 
//       running and pressing Ctrl-C
// ============================================================================
#include <iostream>
#include <csignal>
#include <unistd.h>
using namespace std;
 
// function prototype
void SignalHandlerFunc(int arg);
 
// global variable
int count = 10;
 
int main()
{
    // overide the default signal handler (CTRL-C)
    // with our own "SignalHandlerFunc" function
    signal(SIGINT, SignalHandlerFunc);
 
    cerr<<"nPlease press CTRL-Cnn";
 
    // loop until condition is met
    do{
        sleep(1);
    }while(count > 0);
 
    // press ENTER on the keyboard to end
    // the program once all "lives" are lost
    cin.get();
 
    return 0;
}// end of main
 
/**
 * This function handles the signal
 * @param arg - the signal number
 */
void SignalHandlerFunc(int arg)
{
    // display text when user presses CTRL-C
    if(count > 0)
    {
        cerr<<" Haha I have "<<count<<" lives!n";
    }
    else
    {
        cerr<<" ** Ahh you got me...n";
    }
    --count;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

The following is sample output:

Please press CTRL-C
^C Haha I have 10 lives! ^C Haha I have 9 lives! ^C Haha I have 8 lives! ^C Haha I have 7 lives! ^C Haha I have 6 lives! ^C Haha I have 5 lives! ^C Haha I have 4 lives! ^C Haha I have 3 lives! ^C Haha I have 2 lives! ^C Haha I have 1 lives! ^C ** Ahh you got me...

C++ || Snippet – How To Convert A Decimal Number Into Binary

March 10, 2013 admin No comments

This page will demonstrate how to convert a decimal number (i.e a whole number) into its binary equivalent. So for example, if the decimal number of 26 was entered into the program, it would display the converted binary value of 11010.

REQUIRED KNOWLEDGE FOR THIS SNIPPET

How To Count In Binary The "Long" Datatype - What Is It? While Loops Online Binary to Decimal Converter - Verify For Correct Results How To Reverse A String

If you are looking for sample code which converts binary to decimal, check back here soon!





		
		
			Convert A Decimal Number Into Binary
			
C++
			
			#include <iostream>
#include <string>
#include <algorithm> 
using namespace std;

// function prototype
string DecToBin(long long decNum);

int main()
{
	// declare variables
	long long decNum = 0;
	string binaryNum=""; // use a string instead of an int to avoid
				  // overflow, because binary numbers can grow large quick

	cout<<"Please enter an integer value: ";
	cin >> decNum;

	if(decNum < 0)
	{
		binaryNum = "-";
	}

	// call function to convert decimal to binary
	binaryNum += DecToBin(decNum);

	// display data to user
	cout<<"nThe integer value of "<<decNum<<" = "<<binaryNum<<" in binary"<<endl;

	return 0;
}

string DecToBin(long long decNum)
{
	string binary = ""; // use this string to save the binary number

	if(decNum < 0) // if input is a neg number, make it positive
	{               
		decNum *= -1;
	}          
          
	// converts decimal to binary using division and modulus
	while(decNum > 0)
	{
		binary += (decNum % 2)+'0'; // convert int to char
		decNum /= 2;
	}

	// reverse the string
	reverse(binary.begin(), binary.end());

	return binary;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
				
						#include <iostream>
#include <string>
#include <algorithm> 
using namespace std;
 
// function prototype
string DecToBin(long long decNum);
 
int main()
{
	// declare variables
	long long decNum = 0;
	string binaryNum=""; // use a string instead of an int to avoid
				  // overflow, because binary numbers can grow large quick
 
	cout<<"Please enter an integer value: ";
	cin >> decNum;
 
	if(decNum < 0)
	{
		binaryNum = "-";
	}
 
	// call function to convert decimal to binary
	binaryNum += DecToBin(decNum);
 
	// display data to user
	cout<<"nThe integer value of "<<decNum<<" = "<<binaryNum<<" in binary"<<endl;
 
	return 0;
}
 
string DecToBin(long long decNum)
{
	string binary = ""; // use this string to save the binary number
 
	if(decNum < 0) // if input is a neg number, make it positive
	{               
		decNum *= -1;
	}          
          
	// converts decimal to binary using division and modulus
	while(decNum > 0)
	{
		binary += (decNum % 2)+'0'; // convert int to char
		decNum /= 2;
	}
 
	// reverse the string
	reverse(binary.begin(), binary.end());
 
	return binary;
}// http://programmingnotes.org/

The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output
Note: The code was compiled 3 separate times to display different output

====== RUN 1 ======
Please enter an integer value: 1987 The integer value of 1987 = 11111000011 in binary ====== RUN 2 ====== Please enter an integer value: -26 The integer value of -26 = -11010 in binary ====== RUN 3 ====== Please enter an integer value: 12345678910
The integer value of 12345678910 = 1011011111110111000001110000111110 in binary

C++ || Snippet – Simple Linked List Using Delete, Insert, & Display Functions

August 18, 2012 admin No comments

The following is sample code for a simple linked list, which implements the following functions: “Delete, Insert, and Display.”

The sample code provided on this page is a stripped down version of a more robust linked list class which was previously discussed on this site. Sample code for that can be found here.

It is recommended you check that out as the functions implemented within that class are very useful.





		
		
			Simple Linked List
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Aug 18, 2012
//    Taken From: http://programmingnotes.org/
//    File:  SimpleList.cpp
//    Description: Demonstrates the use of a simple linked list.
// ============================================================================
#include <iostream>
#include <string>
using namespace std;

struct node
{
    /* -- you can use different data types here
         -- instead of just a string
    char letter;
    int number;
    double fNumber;
    */
    string name;
    node* next;
};

// global variables
// this is the front of the list
node* head = NULL;

// function prototype
void Insert(string info);
void Delete(string info);
void Display();
void DestroyList();

int main()
{
    // if you want to insert data into the list
    // this is one way you can do it, using a 'temp' pointer
    node* temp = new node;
    temp->name = "My Programming Notes";
    temp->next = NULL;

    // set the head node to the data thats in the 'temp' pointer
    head = temp;

    // display data to the screen
    cout << head->name <<endl<<endl;

    // use the insert function to add new data to the list
    // NOTE: you could have also used the 'insert' function ^ above
    // to place data into the list
    Insert("Is An Awesome Site!");

    // insert more data into the list
    Insert("August");
    Display();

    // delete the selected text from the list
    Delete("August");
    Display();

    // destroy the current pointers in the list
    // after you are finished using them
    DestroyList();

    return 0;
}// end of main

void Insert(string info)
{
    node* newItem = new node;
    newItem->name = info;
    newItem->next = NULL;

    // if the list is empty, add new item to the front
    if(head == NULL)
    {
        head = newItem;
    }
    else // if the list isnt empty, add new item to the end
    {
        node* iter = head;
        while(iter->next != NULL)
        {
            iter = iter->next;
        }
        iter->next = newItem;
    }
}// end of Insert

void Delete(string info)
{
    node* iter = head;

    // if the list is empty, do nothing
    if(head == NULL)
    {
        return;
    }
    // delete the first item in the list
    else if(head->name == info)
    {
        head = head->next;
        delete iter;
    }
    // search the list until we find the desired item
    else
    {
        while(iter->next != NULL)
        {
            if(iter->next->name == info)
            {
                node* deleteNode = iter->next;
                iter->next = iter->next->next;
                delete deleteNode;
                break;
            }
            iter = iter->next;
        }
    }
}// end of Delete

void Display()
{
    node* iter = head;
    // traverse thru the list, displaying the
    // text at each node location
    while(iter != NULL)
    {
        cout<<iter->name<<endl;
        iter = iter->next;
    }
    cout<<endl;
}// end of Display

void DestroyList()
{
    if(head != NULL)
    {
        cout << "\n\nDestroying nodes...\n";
        while(head != NULL)
        {
            node* temp = head;
            cout << temp->name <<endl;
            head = head->next;
            delete temp;
        }
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Aug 18, 2012
//    Taken From: http://programmingnotes.org/
//    File:  SimpleList.cpp
//    Description: Demonstrates the use of a simple linked list.
// ============================================================================
#include <iostream>
#include <string>
using namespace std;
 
struct node
{
    /* -- you can use different data types here
         -- instead of just a string
    char letter;
    int number;
    double fNumber;
    */
    string name;
    node* next;
};
 
// global variables
// this is the front of the list
node* head = NULL;
 
// function prototype
void Insert(string info);
void Delete(string info);
void Display();
void DestroyList();
 
int main()
{
    // if you want to insert data into the list
    // this is one way you can do it, using a 'temp' pointer
    node* temp = new node;
    temp->name = "My Programming Notes";
    temp->next = NULL;
 
    // set the head node to the data thats in the 'temp' pointer
    head = temp;
 
    // display data to the screen
    cout << head->name <<endl<<endl;
 
    // use the insert function to add new data to the list
    // NOTE: you could have also used the 'insert' function ^ above
    // to place data into the list
    Insert("Is An Awesome Site!");
 
    // insert more data into the list
    Insert("August");
    Display();
 
    // delete the selected text from the list
    Delete("August");
    Display();
 
    // destroy the current pointers in the list
    // after you are finished using them
    DestroyList();
 
    return 0;
}// end of main
 
void Insert(string info)
{
    node* newItem = new node;
    newItem->name = info;
    newItem->next = NULL;
 
    // if the list is empty, add new item to the front
    if(head == NULL)
    {
        head = newItem;
    }
    else // if the list isnt empty, add new item to the end
    {
        node* iter = head;
        while(iter->next != NULL)
        {
            iter = iter->next;
        }
        iter->next = newItem;
    }
}// end of Insert
 
void Delete(string info)
{
    node* iter = head;
 
    // if the list is empty, do nothing
    if(head == NULL)
    {
        return;
    }
    // delete the first item in the list
    else if(head->name == info)
    {
        head = head->next;
        delete iter;
    }
    // search the list until we find the desired item
    else
    {
        while(iter->next != NULL)
        {
            if(iter->next->name == info)
            {
                node* deleteNode = iter->next;
                iter->next = iter->next->next;
                delete deleteNode;
                break;
            }
            iter = iter->next;
        }
    }
}// end of Delete
 
void Display()
{
    node* iter = head;
    // traverse thru the list, displaying the
    // text at each node location
    while(iter != NULL)
    {
        cout<<iter->name<<endl;
        iter = iter->next;
    }
    cout<<endl;
}// end of Display
 
void DestroyList()
{
    if(head != NULL)
    {
        cout << "\n\nDestroying nodes...\n";
        while(head != NULL)
        {
            node* temp = head;
            cout << temp->name <<endl;
            head = head->next;
            delete temp;
        }
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output

My Programming Notes
My Programming Notes Is An Awesome Site! August [DELETE THE TEXT "AUGUST"] My Programming Notes Is An Awesome Site!
Destroying nodes... My Programming Notes Is An Awesome Site!

C++ || Snippet – Custom Template Linked List Sample Code

July 26, 2012 admin 1 Comment

This page will consist of sample code for a singly linked list, which is loosely based on the built in C++ “List” library. Provided in the linked list class are the following functions:





		
		
			* PushFront - Adds new item to the front of the list (LIFO)

* PushBack - Adds new item to the back of the list (FIFO)

* PopFront - Returns & removes first item from the list

* PopBack - Returns & removes last item from the list

* Front - Returns (but does not delete) the first item from the list

* Back - Returns (but does not delete) the last item from the list

* Delete - Searches and deletes the requested item

* Display - Display all the current contents in the list

* Replace - Replaces existing item from the list with a new item
            If existing item cannot be found, the new item is added to the back of the list

* InsertBefore - Inserts new item before the existing item. 
                If existing item cannot be found, the new item is added to the back of the list

* InsertAfter - Inserts new item after the existing item. 
                If existing item cannot be found, the new item is added to the back of the list

* InsertInOrder - Inserts new item in numerical order, from lowest to highest

* Size - Return the current size of the list

* MakeEmpty - Initializes the list to an empty state 
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
				
						* PushFront - Adds new item to the front of the list (LIFO)
 
* PushBack - Adds new item to the back of the list (FIFO)
 
* PopFront - Returns & removes first item from the list
 
* PopBack - Returns & removes last item from the list
 
* Front - Returns (but does not delete) the first item from the list
 
* Back - Returns (but does not delete) the last item from the list
 
* Delete - Searches and deletes the requested item
 
* Display - Display all the current contents in the list
 
* Replace - Replaces existing item from the list with a new item
            If existing item cannot be found, the new item is added to the back of the list
 
* InsertBefore - Inserts new item before the existing item. 
                If existing item cannot be found, the new item is added to the back of the list
 
* InsertAfter - Inserts new item after the existing item. 
                If existing item cannot be found, the new item is added to the back of the list
 
* InsertInOrder - Inserts new item in numerical order, from lowest to highest
 
* Size - Return the current size of the list
 
* MakeEmpty - Initializes the list to an empty state

From the following, the functions of interest to look out for are the “Delete, Display, Replace, InsertBefore, InsertAfter, and InsertInOrder” functions as they are typically used as programming assignments in many C++ Data structures courses to further demonstrate how linked lists operate.





		
		
			#include 'LinkedList.h'
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jul 26, 2012
//    Taken From: http://programmingnotes.org/
//    File:  LinkedList.h
//    Description: This is a class which implements various functions which
//          demonstrates the use of a Linked List. 
// ============================================================================
#include <iostream>

template <class ItemType>
class LinkedList
{
public:
    LinkedList();
        /*   Function: Constructor initializes list 
            Precondition: None
            Postcondition: Defines private variables */
    bool IsEmpty();
        /*   Function: Determines whether queue is empty
            Precondition: List has been created
            Postcondition: The function = true if the list is empty and the
                             function = false if list is not empty */
    void PushFront(ItemType item);
        /*   Function: Adds new item to the front of the list (LIFO)
            Precondition:  List has been created and is not full
            Postcondition: Item is in the list */
    void PushBack(ItemType item);
        /*   Function: Adds new item to the back of the list (FIFO)
            Precondition:  List has been created and is not full
            Postcondition: Item is in the list */
    ItemType PopFront();
        /*   Function: Returns & removes first item from the last
            Precondition: List has been initialized
            Postcondition: The first item in the list is removed */
    ItemType PopBack();
        /*   Function: Returns & removes last item from the list
            Precondition: List has been initialized
            Postcondition: The last item in the list is removed */
    ItemType Front();
        /*   Function: Returns (but does not delete) the first item from the list
            Precondition: List has been initialized
            Postcondition: The first item in the list is removed */
    ItemType Back();
        /*   Function: Returns (but does not delete) the last item from the list
            Precondition: List has been initialized
            Postcondition: The last item in the list is removed */
    void Delete(ItemType item);
        /*   Function: Searches and deletes the requested item
            Precondition:  List has been created and is not empty
            Postcondition: Item removed from the list */
    void Display();
        /*   Function: Display all the current contents in the list
            Precondition:  List has been created and is not empty
            Postcondition: List is displayed to the screen */
    void Replace(ItemType initial, ItemType replace);
        /*   Function: Replaces existing item from the list with a new item
            Precondition:  List has been created and is not empty
            Postcondition: Initial item is replaced with the new one */
    void InsertBefore(ItemType initial, ItemType newItem);
        /*   Function: Inserts new item before the existing item
            Precondition:  List has been created and is not empty
            Postcondition: New item is inserted before the existing item */
    void InsertAfter(ItemType initial, ItemType newItem);
        /*   Function: Inserts new item after the existing item
            Precondition:  List has been created and is not empty
            Postcondition: New item is inserted after the existing item */
    void InsertInOrder(ItemType item);  
        /*   Function: Inserts new item in numerical order, from lowest to highest
            Precondition:  List has been created and is not empty
            Postcondition: The list is sorted in numerical order */
    int Size();
        /*   Function: Return the current size of the list
            Precondition: List has been initialized
            Postcondition: The size of the list is returned */
    void MakeEmpty();
        /*   Function: Initializes the list to an empty state 
            Precondition: List has been created
            Postcondition: List no longer exists */
    ~LinkedList();
        /*   Function: Deletes all the items in the list
            Precondition: List has been declared
            Postcondition: List no longer exists */

private:
    struct node
    {
        ItemType info;
        node* next;
    };
    node* head; 
    int size;
};

//=========================  Implementation  ================================//

template <class ItemType>
LinkedList<ItemType>::LinkedList()
{
    head = NULL;
    size = 0;
}// end of LinkedList

template <class ItemType>
bool LinkedList<ItemType>::IsEmpty()
{
    return (head==NULL);
}// end of IsEmpty

template <class ItemType>
void LinkedList<ItemType>::PushFront(ItemType item)
{
    // LIFO 
    node* temp = new node;
    temp-> info = item;
    temp-> next = head;
    head = temp;
    ++size;
}// end of PushFront

template <class ItemType>
void LinkedList<ItemType>::PushBack(ItemType item)
{
    // FIFO
    node* temp = new node;
    temp->info = item;
    temp->next = NULL;
    
    if(IsEmpty())
    {
        head=temp;
    }
    else
    {
        node* temp2 = head;        
        while(temp2->next!=NULL)
        {
            temp2=temp2->next;
        }
        temp2->next=temp;
    }
    ++size;
}// end of PushBack

template <class ItemType>
ItemType LinkedList<ItemType>::PopFront()
{
    if(IsEmpty())
    {
        std::cout<<"\nLIST EMPTY\n";
    }
    else
    {  
        ItemType item = head-> info;  
        node* temp = head;
        head = head-> next;
        delete temp;
        --size;
        return item;
    }
}// end of PopFront

template <class ItemType>
ItemType LinkedList<ItemType>::PopBack()
{
    if(IsEmpty())
    {
        std::cout<<"\nLIST EMPTY\n";
    }
    else if(size == 1)
    {
        ItemType item = PopFront();
        return item;
    }
    else
    {
        node* temp = head;
        ItemType item;
        while(temp->next != NULL)
        {
            if(temp->next->next==NULL)
            {
                node* temp2=temp->next;
                temp->next=temp->next->next;
                item = temp2-> info;
                delete temp2;
                break;
            }
            temp=temp->next;
        }
        --size;
        return item;
    }   
}// end of PopBack

template <class ItemType>
ItemType LinkedList<ItemType>::Front()
{
    if(IsEmpty())
    {
        std::cout<<"\nLIST EMPTY\n";
    }
    else
    { 
        return head-> info;
    }
}// end of Front

template <class ItemType>
ItemType LinkedList<ItemType>::Back() 
{
    if(IsEmpty())
    {
        std::cout<<"\nLIST EMPTY\n";
    }
    else
    {
        node* temp = head; 
        while(temp->next != NULL)
        {
            temp = temp-> next;
        }
        ItemType item = temp-> info;
        return item;
    }   
}// end of Back

template <class ItemType>
void LinkedList<ItemType>::Delete(ItemType item)
{
    node* temp=head;
    if(IsEmpty())
    {
        return;
    }
    else if(temp->info==item)
    {
        head=head->next;
        delete temp;
        --size;
    }
    else
    {
        while(temp->next!=NULL)
        {
            if(temp->next->info==item)
            {
                node* temp2=temp->next;
                temp->next=temp->next->next;
                delete temp2;
                --size;
                break;
            }
            temp=temp->next;
        }
    }
}// end of Delete

template <class ItemType>
void LinkedList<ItemType>::Display()
{
    node* temp=head;
    while(temp!=NULL)
    {
        std::cout<<temp->info<<std::endl;
        temp=temp->next;
    }
}// end of Display

template <class ItemType>
void LinkedList<ItemType>::Replace(ItemType initial, ItemType replace)
{
    node* temp=head;
    if(IsEmpty())
    {
        PushFront(replace);
    }
    else if(temp->info==initial)
    {
        temp->info=replace;
    }
    else
    {        
        while(temp->next!=NULL)
        {
            if(temp->info==initial)
            {
                temp->info=replace;
                break;
            }
            temp=temp->next;
        }
        if(temp->next==NULL)
        {
            PushBack(replace);
        }
    }
}// end of Replace

template <class ItemType>
void LinkedList<ItemType>::InsertBefore(ItemType initial, ItemType newItem)
{
    node* temp=head;
    node* temp2=new node;
    temp2->info=initial;
    temp2->next=NULL;     
    
    if(IsEmpty())
    {
        PushFront(newItem);
    }
    else if(temp->info==initial)
    {
        temp->info=newItem; 
        temp2->next=temp->next;
        temp->next=temp2;
        ++size;
    }
    else
    {
        while(temp->next!=NULL)
        {
            if(temp->info==initial)
            {
                temp->info=newItem; 
                temp2->next=temp->next;
                temp->next=temp2;
                ++size;
                break;
            }
            temp=temp->next;           
        }
        if(temp->next==NULL)
        {
            PushBack(newItem);
        }
    }
}// end of InsertBefore

template <class ItemType>
void LinkedList<ItemType>::InsertAfter(ItemType initial, ItemType newItem)
{
    node* temp=head;
    node* temp2=new node;
    temp2->info=newItem;
    temp2->next=NULL;
    
    if(IsEmpty())
    {
        PushFront(newItem);
    }
    else if(temp->info==initial)
    {
        temp2->next=temp->next;
        temp->next=temp2;
        ++size;
    }
    else
    {   
        while(temp->next!=NULL)
        {
            if(temp->info==initial)
            {
                temp2->next=temp->next;
                temp->next=temp2;
                ++size;
                break;
            }
            temp=temp->next;
        }
        if(temp->next==NULL)
        {
            PushBack(newItem);
        }
    }
}// end of InsertAfter

template <class ItemType>
void LinkedList<ItemType>::InsertInOrder(ItemType item)
{
    if(IsEmpty())
    {
        PushFront(item);
    }
    else
    {
        node* temp=head;
        node* temp2=new node;
    
        if(item <=(temp->info))
        {  
            ItemType placeHolder=temp->info;
            temp2->info=placeHolder;
            temp->info=item;
            temp2->next=temp->next;
            temp->next=temp2;
            ++size;
        } 
        else
        {
            while(temp->next!=NULL)
            {       
                if(((temp->info) <= item) && (item <= (temp->next->info)))
                {           
                    temp2->info=item;
                    temp2->next=temp->next;
                    temp->next=temp2;
                    ++size;
                    return;
                }
                temp=temp->next;
            }
            if(temp->next==NULL)
            {
                PushBack(item);
            }
        }
    }
}// end of InsertInOrder

template <class ItemType>
int LinkedList<ItemType>::Size()
{
    if(IsEmpty())
    {
        std::cout<<"\nLIST EMPTY\n";
    }
    return size;
}// end of Size 

template <class ItemType>
void LinkedList<ItemType>::MakeEmpty()
{
    if(!IsEmpty())
    {
        std::cout << "\nDestroying nodes...\n";
        while(!IsEmpty())
        {
            node* temp = head;
            //std::cout << temp-> info << '\n';
            head = head-> next;
            delete temp;
        }
        size = 0;
    }
}// end of MakeEmpty

template <class ItemType>
LinkedList<ItemType>::~LinkedList()
{
    MakeEmpty();
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jul 26, 2012
//    Taken From: http://programmingnotes.org/
//    File:  LinkedList.h
//    Description: This is a class which implements various functions which
//          demonstrates the use of a Linked List. 
// ============================================================================
#include <iostream>
 
template <class ItemType>
class LinkedList
{
public:
    LinkedList();
        /*   Function: Constructor initializes list 
            Precondition: None
            Postcondition: Defines private variables */
    bool IsEmpty();
        /*   Function: Determines whether queue is empty
            Precondition: List has been created
            Postcondition: The function = true if the list is empty and the
                             function = false if list is not empty */
    void PushFront(ItemType item);
        /*   Function: Adds new item to the front of the list (LIFO)
            Precondition:  List has been created and is not full
            Postcondition: Item is in the list */
    void PushBack(ItemType item);
        /*   Function: Adds new item to the back of the list (FIFO)
            Precondition:  List has been created and is not full
            Postcondition: Item is in the list */
    ItemType PopFront();
        /*   Function: Returns & removes first item from the last
            Precondition: List has been initialized
            Postcondition: The first item in the list is removed */
    ItemType PopBack();
        /*   Function: Returns & removes last item from the list
            Precondition: List has been initialized
            Postcondition: The last item in the list is removed */
    ItemType Front();
        /*   Function: Returns (but does not delete) the first item from the list
            Precondition: List has been initialized
            Postcondition: The first item in the list is removed */
    ItemType Back();
        /*   Function: Returns (but does not delete) the last item from the list
            Precondition: List has been initialized
            Postcondition: The last item in the list is removed */
    void Delete(ItemType item);
        /*   Function: Searches and deletes the requested item
            Precondition:  List has been created and is not empty
            Postcondition: Item removed from the list */
    void Display();
        /*   Function: Display all the current contents in the list
            Precondition:  List has been created and is not empty
            Postcondition: List is displayed to the screen */
    void Replace(ItemType initial, ItemType replace);
        /*   Function: Replaces existing item from the list with a new item
            Precondition:  List has been created and is not empty
            Postcondition: Initial item is replaced with the new one */
    void InsertBefore(ItemType initial, ItemType newItem);
        /*   Function: Inserts new item before the existing item
            Precondition:  List has been created and is not empty
            Postcondition: New item is inserted before the existing item */
    void InsertAfter(ItemType initial, ItemType newItem);
        /*   Function: Inserts new item after the existing item
            Precondition:  List has been created and is not empty
            Postcondition: New item is inserted after the existing item */
    void InsertInOrder(ItemType item);  
        /*   Function: Inserts new item in numerical order, from lowest to highest
            Precondition:  List has been created and is not empty
            Postcondition: The list is sorted in numerical order */
    int Size();
        /*   Function: Return the current size of the list
            Precondition: List has been initialized
            Postcondition: The size of the list is returned */
    void MakeEmpty();
        /*   Function: Initializes the list to an empty state 
            Precondition: List has been created
            Postcondition: List no longer exists */
    ~LinkedList();
        /*   Function: Deletes all the items in the list
            Precondition: List has been declared
            Postcondition: List no longer exists */
 
private:
    struct node
    {
        ItemType info;
        node* next;
    };
    node* head; 
    int size;
};
 
//=========================  Implementation  ================================//
 
template <class ItemType>
LinkedList<ItemType>::LinkedList()
{
    head = NULL;
    size = 0;
}// end of LinkedList
 
template <class ItemType>
bool LinkedList<ItemType>::IsEmpty()
{
    return (head==NULL);
}// end of IsEmpty
 
template <class ItemType>
void LinkedList<ItemType>::PushFront(ItemType item)
{
    // LIFO 
    node* temp = new node;
    temp-> info = item;
    temp-> next = head;
    head = temp;
    ++size;
}// end of PushFront
 
template <class ItemType>
void LinkedList<ItemType>::PushBack(ItemType item)
{
    // FIFO
    node* temp = new node;
    temp->info = item;
    temp->next = NULL;
    
    if(IsEmpty())
    {
        head=temp;
    }
    else
    {
        node* temp2 = head;        
        while(temp2->next!=NULL)
        {
            temp2=temp2->next;
        }
        temp2->next=temp;
    }
    ++size;
}// end of PushBack
 
template <class ItemType>
ItemType LinkedList<ItemType>::PopFront()
{
    if(IsEmpty())
    {
        std::cout<<"\nLIST EMPTY\n";
    }
    else
    {  
        ItemType item = head-> info;  
        node* temp = head;
        head = head-> next;
        delete temp;
        --size;
        return item;
    }
}// end of PopFront
 
template <class ItemType>
ItemType LinkedList<ItemType>::PopBack()
{
    if(IsEmpty())
    {
        std::cout<<"\nLIST EMPTY\n";
    }
    else if(size == 1)
    {
        ItemType item = PopFront();
        return item;
    }
    else
    {
        node* temp = head;
        ItemType item;
        while(temp->next != NULL)
        {
            if(temp->next->next==NULL)
            {
                node* temp2=temp->next;
                temp->next=temp->next->next;
                item = temp2-> info;
                delete temp2;
                break;
            }
            temp=temp->next;
        }
        --size;
        return item;
    }   
}// end of PopBack
 
template <class ItemType>
ItemType LinkedList<ItemType>::Front()
{
    if(IsEmpty())
    {
        std::cout<<"\nLIST EMPTY\n";
    }
    else
    { 
        return head-> info;
    }
}// end of Front
 
template <class ItemType>
ItemType LinkedList<ItemType>::Back() 
{
    if(IsEmpty())
    {
        std::cout<<"\nLIST EMPTY\n";
    }
    else
    {
        node* temp = head; 
        while(temp->next != NULL)
        {
            temp = temp-> next;
        }
        ItemType item = temp-> info;
        return item;
    }   
}// end of Back
 
template <class ItemType>
void LinkedList<ItemType>::Delete(ItemType item)
{
    node* temp=head;
    if(IsEmpty())
    {
        return;
    }
    else if(temp->info==item)
    {
        head=head->next;
        delete temp;
        --size;
    }
    else
    {
        while(temp->next!=NULL)
        {
            if(temp->next->info==item)
            {
                node* temp2=temp->next;
                temp->next=temp->next->next;
                delete temp2;
                --size;
                break;
            }
            temp=temp->next;
        }
    }
}// end of Delete
 
template <class ItemType>
void LinkedList<ItemType>::Display()
{
    node* temp=head;
    while(temp!=NULL)
    {
        std::cout<<temp->info<<std::endl;
        temp=temp->next;
    }
}// end of Display
 
template <class ItemType>
void LinkedList<ItemType>::Replace(ItemType initial, ItemType replace)
{
    node* temp=head;
    if(IsEmpty())
    {
        PushFront(replace);
    }
    else if(temp->info==initial)
    {
        temp->info=replace;
    }
    else
    {        
        while(temp->next!=NULL)
        {
            if(temp->info==initial)
            {
                temp->info=replace;
                break;
            }
            temp=temp->next;
        }
        if(temp->next==NULL)
        {
            PushBack(replace);
        }
    }
}// end of Replace
 
template <class ItemType>
void LinkedList<ItemType>::InsertBefore(ItemType initial, ItemType newItem)
{
    node* temp=head;
    node* temp2=new node;
    temp2->info=initial;
    temp2->next=NULL;     
    
    if(IsEmpty())
    {
        PushFront(newItem);
    }
    else if(temp->info==initial)
    {
        temp->info=newItem; 
        temp2->next=temp->next;
        temp->next=temp2;
        ++size;
    }
    else
    {
        while(temp->next!=NULL)
        {
            if(temp->info==initial)
            {
                temp->info=newItem; 
                temp2->next=temp->next;
                temp->next=temp2;
                ++size;
                break;
            }
            temp=temp->next;           
        }
        if(temp->next==NULL)
        {
            PushBack(newItem);
        }
    }
}// end of InsertBefore
 
template <class ItemType>
void LinkedList<ItemType>::InsertAfter(ItemType initial, ItemType newItem)
{
    node* temp=head;
    node* temp2=new node;
    temp2->info=newItem;
    temp2->next=NULL;
    
    if(IsEmpty())
    {
        PushFront(newItem);
    }
    else if(temp->info==initial)
    {
        temp2->next=temp->next;
        temp->next=temp2;
        ++size;
    }
    else
    {   
        while(temp->next!=NULL)
        {
            if(temp->info==initial)
            {
                temp2->next=temp->next;
                temp->next=temp2;
                ++size;
                break;
            }
            temp=temp->next;
        }
        if(temp->next==NULL)
        {
            PushBack(newItem);
        }
    }
}// end of InsertAfter
 
template <class ItemType>
void LinkedList<ItemType>::InsertInOrder(ItemType item)
{
    if(IsEmpty())
    {
        PushFront(item);
    }
    else
    {
        node* temp=head;
        node* temp2=new node;
    
        if(item <=(temp->info))
        {  
            ItemType placeHolder=temp->info;
            temp2->info=placeHolder;
            temp->info=item;
            temp2->next=temp->next;
            temp->next=temp2;
            ++size;
        } 
        else
        {
            while(temp->next!=NULL)
            {       
                if(((temp->info) <= item) && (item <= (temp->next->info)))
                {           
                    temp2->info=item;
                    temp2->next=temp->next;
                    temp->next=temp2;
                    ++size;
                    return;
                }
                temp=temp->next;
            }
            if(temp->next==NULL)
            {
                PushBack(item);
            }
        }
    }
}// end of InsertInOrder
 
template <class ItemType>
int LinkedList<ItemType>::Size()
{
    if(IsEmpty())
    {
        std::cout<<"\nLIST EMPTY\n";
    }
    return size;
}// end of Size 
 
template <class ItemType>
void LinkedList<ItemType>::MakeEmpty()
{
    if(!IsEmpty())
    {
        std::cout << "\nDestroying nodes...\n";
        while(!IsEmpty())
        {
            node* temp = head;
            //std::cout << temp-> info << '\n';
            head = head-> next;
            delete temp;
        }
        size = 0;
    }
}// end of MakeEmpty
 
template <class ItemType>
LinkedList<ItemType>::~LinkedList()
{
    MakeEmpty();
}// http://programmingnotes.org/

===== DEMONSTRATION HOW TO USE =====

Use of the above template class is the same as its STL counterpart. Here is a sample program demonstrating its use.





		
		
			How To Use #include 'LinkedList.h'
			
C++
			
			#include <iostream>
#include <string>
#include "LinkedList.h"
using namespace std;

int main()
{
    // declare variables, using a string as
    // the item type for the class. 

    // NOTE: you can also use an int, float, double etc.
    // instead of a string
    LinkedList<string> list;

    // demontrate the "InOrder" function
    cout<<"** These are names of fruits sorted in order"
        <<" using the 'InsertInOrder()' function:\n\n";
    list.InsertInOrder("Tomato");
    list.InsertInOrder("Orange");
    list.InsertInOrder("Apple");
    list.InsertInOrder("Plum");
    list.Display();

    cout<<"\nThere is currently "<<list.Size()<<" items in the list\n\n";

    // demonstrate the "Delete" function
    cout<<"\n** Here is the same list with the word 'Plum' deleted"
        << "\nusing the 'Delete()' function:\n\n";
    list.Delete("Plum");
    list.Display();

    cout<<"\nThere is currently "<<list.Size()<<" items in the listnn";

    // demonstrate the "InsertAfter" function
    cout<<"\n** Now the word 'Bike' will be added to the list,"
        <<"\nright after the word 'Apple' using the "
        <<"'InsertAfter()' function:\n\n";
    list.InsertAfter("Apple","Bike");
    list.Display();

    cout<<"\nThere is currently "<<list.Size()<<" items in the list\n\n";

    // demonstrate the "InsertBefore" function
    cout<<"\n** Now the name 'Jessica' will be added to the list,"
        <<"\nright before the word 'Orange' using the "
        <<"'InsertBefore()' function:\n\n";
    list.InsertBefore("Orange","Jessica");
    list.Display();

    cout<<"\nThere is currently "<<list.Size()<<" items in the list\n\n";

    // demonstrate the "Replace" function
    cout<<"\n** The word 'Orange' will now be replaced with the name,"
        <<"\n'Kat' using the 'Replace()' function:\n\n";
    list.Replace("Orange","Kat");
    list.Display();

    cout<<"\nThere is currently "<<list.Size()<<" items in the list\n\n";
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
				
						#include <iostream>
#include <string>
#include "LinkedList.h"
using namespace std;
 
int main()
{
    // declare variables, using a string as
    // the item type for the class. 
 
    // NOTE: you can also use an int, float, double etc.
    // instead of a string
    LinkedList<string> list;
 
    // demontrate the "InOrder" function
    cout<<"** These are names of fruits sorted in order"
        <<" using the 'InsertInOrder()' function:\n\n";
    list.InsertInOrder("Tomato");
    list.InsertInOrder("Orange");
    list.InsertInOrder("Apple");
    list.InsertInOrder("Plum");
    list.Display();
 
    cout<<"\nThere is currently "<<list.Size()<<" items in the list\n\n";
 
    // demonstrate the "Delete" function
    cout<<"\n** Here is the same list with the word 'Plum' deleted"
        << "\nusing the 'Delete()' function:\n\n";
    list.Delete("Plum");
    list.Display();
 
    cout<<"\nThere is currently "<<list.Size()<<" items in the listnn";
 
    // demonstrate the "InsertAfter" function
    cout<<"\n** Now the word 'Bike' will be added to the list,"
        <<"\nright after the word 'Apple' using the "
        <<"'InsertAfter()' function:\n\n";
    list.InsertAfter("Apple","Bike");
    list.Display();
 
    cout<<"\nThere is currently "<<list.Size()<<" items in the list\n\n";
 
    // demonstrate the "InsertBefore" function
    cout<<"\n** Now the name 'Jessica' will be added to the list,"
        <<"\nright before the word 'Orange' using the "
        <<"'InsertBefore()' function:\n\n";
    list.InsertBefore("Orange","Jessica");
    list.Display();
 
    cout<<"\nThere is currently "<<list.Size()<<" items in the list\n\n";
 
    // demonstrate the "Replace" function
    cout<<"\n** The word 'Orange' will now be replaced with the name,"
        <<"\n'Kat' using the 'Replace()' function:\n\n";
    list.Replace("Orange","Kat");
    list.Display();
 
    cout<<"\nThere is currently "<<list.Size()<<" items in the list\n\n";
}// http://programmingnotes.org/

Once compiled, you should get this as your output

** These are names of fruits sorted in order using the 'InsertInOrder()' function:
Apple Orange Plum Tomato There is currently 4 items in the list ** Here is the same list with the word 'Plum' deleted using the 'Delete()' function: Apple Orange Tomato There is currently 3 items in the list ** Now the word 'Bike' will be added to the list, right after the word 'Apple' using the 'InsertAfter()' function: Apple Bike Orange Tomato There is currently 4 items in the list ** Now the name 'Jessica' will be added to the list, right before the word 'Orange' using the 'InsertBefore()' function: Apple Bike Jessica Orange Tomato There is currently 5 items in the list ** The word 'Orange' will now be replaced with the name, 'Kat' using the 'Replace()' function: Apple Bike Jessica Kat Tomato
There is currently 5 items in the list

C++ || Snippet – How To Swap Two Numbers Without Using A Third “Temporary” Variable

July 23, 2012 admin No comments

The following are three programs which demonstrates how to swap two numbers without using a third “temporary” variable.

Why would anyone want to swap two numbers without utilizing a third variable? There is no real reason to do so other than the fact that exercises such as these are typically used as programming assignments/interview questions. This is a technique that’s rarely ever practical in a real world setting, but it is still an interesting task nonetheless.





		
		
			#1 - Using Simple Math
			
C++
			
			#include <iostream>
using namespace std;

int main() 
{
	// declare variables
	int x = 0;
	int y = 0;

	// get data
	cout <<"Please enter two numbers: ";
	cin >> x >> y;

	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;

	cout <<"nSwitching the numbers..n";
	
	// switch the numbers using simple math
	x = x+y;
	y = x-y;
	x = x-y;

	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;
	
	return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
				
						#include <iostream>
using namespace std;
 
int main() 
{
	// declare variables
	int x = 0;
	int y = 0;
 
	// get data
	cout <<"Please enter two numbers: ";
	cin >> x >> y;
 
	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;
 
	cout <<"nSwitching the numbers..n";
	
	// switch the numbers using simple math
	x = x+y;
	y = x-y;
	x = x-y;
 
	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;
	
	return 0;
}// http://programmingnotes.org/

SAMPLE OUTPUT:

Please enter two numbers: 7 28
Item #1 = 7 Item #2 = 28 Switching the numbers..
Item #1 = 28 Item #2 = 7





		
		
			#2 - Using The XOR Swap Algorithm
			
C++
			
			#include <iostream>
using namespace std;

int main() 
{
	// declare variables
	int x = 0;
	int y = 0;

	// get data
	cout <<"Please enter two numbers: ";
	cin >> x >> y;

	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;

	cout <<"nSwitching the numbers..n";
	
	// switch the numbers using the xor swap algorithm
	x ^= y;
	y ^= x;
	x ^= y;

	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;
	
	return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
				
						#include <iostream>
using namespace std;
 
int main() 
{
	// declare variables
	int x = 0;
	int y = 0;
 
	// get data
	cout <<"Please enter two numbers: ";
	cin >> x >> y;
 
	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;
 
	cout <<"nSwitching the numbers..n";
	
	// switch the numbers using the xor swap algorithm
	x ^= y;
	y ^= x;
	x ^= y;
 
	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;
	
	return 0;
}// http://programmingnotes.org/

SAMPLE OUTPUT:

Please enter two numbers: 5 12453
Item #1 = 5 Item #2 = 12453 Switching the numbers..
Item #1 = 12453 Item #2 = 5





		
		
			#3 - Using The In-Built Swap Function
			
C++
			
			#include <iostream>
#include <algorithm>
using namespace std;

int main() 
{
	// declare variables
	int x = 0;
	int y = 0;

	// get data
	cout <<"Please enter two numbers: ";
	cin >> x >> y;

	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;

	cout <<"nSwitching the numbers..n";
	
	// switch the numbers using the in-built swap function
	swap(x, y);

	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;
	
	return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						#include <iostream>
#include <algorithm>
using namespace std;
 
int main() 
{
	// declare variables
	int x = 0;
	int y = 0;
 
	// get data
	cout <<"Please enter two numbers: ";
	cin >> x >> y;
 
	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;
 
	cout <<"nSwitching the numbers..n";
	
	// switch the numbers using the in-built swap function
	swap(x, y);
 
	cout <<"nItem #1 = "<<x<<endl;
	cout <<"Item #2 = "<<y<<endl;
	
	return 0;
}// http://programmingnotes.org/

SAMPLE OUTPUT:

Please enter two numbers: 2132 6547546
Item #1 = 2132 Item #2 = 6547546 Switching the numbers..
Item #1 = 6547546 Item #2 = 2132

C++ || Snippet – Palindrome Checker Using A Stack & Queue

July 22, 2012 admin No comments

Click Here For Updated Version Of Program

This page consists of a sample program which demonstrates how to use a stack and a queue to test for a palindrome. This program is great practice for understanding how the two data structures work.

REQUIRED KNOWLEDGE FOR THIS PROGRAM

Structs Classes Template Classes - What Are They? Stacks Queues LIFO - Last In First Out FIFO - First In First Out #include 'SingleQueue.h' #include 'ClassStackListType.h'

This program first asks the user to enter in text which they wish to compare for similarity. The data is then saved into the system using the “enqueue” and “push” functions available within the queue and stack classes. After the data is obtained, a while loop is used to iterate through both classes, checking to see if the characters at each location within both classes are the same. If the text within both classes are the same, it is a palindrome.

NOTE: This program uses two custom template.h classes. To obtain the code for both class, click here and here.





		
		
			Palindrome Checker Using Stack & Queue
			
C++
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jul 22, 2012
//    Taken From: http://programmingnotes.org/
//    File:  palindrome.cpp
//    Description: Demonstrates a palindrome checker using a stack & queue
// ============================================================================
#include <iostream>
#include <cctype>
#include "SingleQueue.h"
#include "ClassStackListType.h"
using namespace std;

int main()
{
    // declare variable
    char singleChar = ' ';
    bool isPalindrome = true;
    SingleQueue<char> queue;
    StackListType<char> stack;

    // get data from user, then place them into the
    // queue and stack for storage. This loop also
    // displays the user input back to the screen via cout
    cout <<"Enter in some text to see if its a palindrome: ";
    while(cin.get(singleChar) && singleChar != '\n')
    {
        cout<<singleChar;
        queue.EnQueue(toupper(singleChar));
        stack.Push(toupper(singleChar));
    }

    // determine if the string is a palindrome
    while((!queue.IsEmpty() && !stack.IsEmpty())
        && isPalindrome)
    {
        if(queue.Front() != stack.Top())
        {
            isPalindrome = false;
        }
        else
        {
            queue.DeQueue();
            stack.Pop();
        }
    }

    // display results to the screen
    if(isPalindrome)
    {
        cout<<" is a palindrome!\n";
    }
    else
    {
        cout<<" is NOT a palindrome..\n";
    }

    return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   Jul 22, 2012
//    Taken From: http://programmingnotes.org/
//    File:  palindrome.cpp
//    Description: Demonstrates a palindrome checker using a stack & queue
// ============================================================================
#include <iostream>
#include <cctype>
#include "SingleQueue.h"
#include "ClassStackListType.h"
using namespace std;
 
int main()
{
    // declare variable
    char singleChar = ' ';
    bool isPalindrome = true;
    SingleQueue<char> queue;
    StackListType<char> stack;
 
    // get data from user, then place them into the
    // queue and stack for storage. This loop also
    // displays the user input back to the screen via cout
    cout <<"Enter in some text to see if its a palindrome: ";
    while(cin.get(singleChar) && singleChar != '\n')
    {
        cout<<singleChar;
        queue.EnQueue(toupper(singleChar));
        stack.Push(toupper(singleChar));
    }
 
    // determine if the string is a palindrome
    while((!queue.IsEmpty() && !stack.IsEmpty())
        && isPalindrome)
    {
        if(queue.Front() != stack.Top())
        {
            isPalindrome = false;
        }
        else
        {
            queue.DeQueue();
            stack.Pop();
        }
    }
 
    // display results to the screen
    if(isPalindrome)
    {
        cout<<" is a palindrome!\n";
    }
    else
    {
        cout<<" is NOT a palindrome..\n";
    }
 
    return 0;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output
(Note: The code was compiled 2 separate times to demonstrate different output)

====== RUN 1 ======
Enter in some text to see if its a palindrome: StEP on No pETS StEP on No pETS is a palindrome! ====== RUN 2 ====== Enter in some text to see if its a palindrome: Hello World
Hello World is NOT a palindrome..

C++ || Convert Numbers To Words Using A Switch Statement

July 21, 2012 admin No comments

This program demonstrates more practice using arrays and switch statements.

REQUIRED KNOWLEDGE FOR THIS PROGRAM

Integer Arrays Cin.get Isdigit For loops While Loops Switch Statements - How To Use

Using “cin.get(),” this program first asks the user to enter in a number (one at a time) that they wish to translate into words. If the text which was entered into the system is a number, the program will save the user input into an integer array. If the text is not a number, the input is discarded. After integer data is obtained, a for loop is used to traverse the integer array, passing the data to a switch statement, which translates the number to text.

This program is very simple, so it does not have the ability to display any number prefixes. As a result, if the number “1858” was entered into the system, the program would output the converted text: “One Eight Five Eight.”





		
		
			Convert Numbers To Words
			
C++
			
			#include <iostream>
#include <cctype>
using namespace std;
 
int main()
{
	// declare variables
	int numberArry[50];
	int numElems=0;
	char singleNum=' ';

	// ask the user for a number
	cout<<"Enter number: ";

	// get data from the user, one character at a time
	while(cin.get(singleNum) && singleNum != 'n')
	{
		// only numbers will be saved into the array, everything
		// else is ignored
		if(isdigit(singleNum))
		{
			// this converts a char into an integer using ascii values
			numberArry[numElems] = (singleNum)-'0'; 
			++numElems;
		}
	}

	cout<<endl;

	// using the data from the array, display the
	// numbers to the screen using a switch statement
	for(int index=0; index < numElems; ++index)
	{
		switch(numberArry[index])
		{
			case 0 :
				cout<<"Zero ";
				break;
			case 1 : 
				cout<<"One ";
				break;
			case 2: 
				cout<<"Two ";
				break;
			case 3: 
				cout<<"Three ";
				break;
			case 4:
				cout<<"Four ";
				break;
			case 5:
				cout<<"Five ";
				break;
			case 6:
				cout<<"Six ";
				break;
			case 7:
				cout<<"Seven ";
				break;
			case 8:
				cout<<"Eight ";
				break;
			case 9:
				cout<<"Nine ";
				break;
			default:
				cout<<"nERROR!n";
				break;
		}
	}
	cout<<endl;

	return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
				
						#include <iostream>
#include <cctype>
using namespace std;
 
int main()
{
	// declare variables
	int numberArry[50];
	int numElems=0;
	char singleNum=' ';
 
	// ask the user for a number
	cout<<"Enter number: ";
 
	// get data from the user, one character at a time
	while(cin.get(singleNum) && singleNum != 'n')
	{
		// only numbers will be saved into the array, everything
		// else is ignored
		if(isdigit(singleNum))
		{
			// this converts a char into an integer using ascii values
			numberArry[numElems] = (singleNum)-'0'; 
			++numElems;
		}
	}
 
	cout<<endl;
 
	// using the data from the array, display the
	// numbers to the screen using a switch statement
	for(int index=0; index < numElems; ++index)
	{
		switch(numberArry[index])
		{
			case 0 :
				cout<<"Zero ";
				break;
			case 1 : 
				cout<<"One ";
				break;
			case 2: 
				cout<<"Two ";
				break;
			case 3: 
				cout<<"Three ";
				break;
			case 4:
				cout<<"Four ";
				break;
			case 5:
				cout<<"Five ";
				break;
			case 6:
				cout<<"Six ";
				break;
			case 7:
				cout<<"Seven ";
				break;
			case 8:
				cout<<"Eight ";
				break;
			case 9:
				cout<<"Nine ";
				break;
			default:
				cout<<"nERROR!n";
				break;
		}
	}
	cout<<endl;
 
	return 0;
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output
Note: The code was compiled four separate times to display different output

======= Run #1 =======
Enter number: 77331 Seven Seven Three Three One ======= Run #2 ======= Enter number: 234-43-1275 Two Three Four Four Three One Two Seven Five ======= Run #3 ======= Enter number: 1(800) 123-5678 One Eight Zero Zero One Two Three Five Six Seven Eight ======= Run #4 ======= Enter number: This 34 Is 24 A 5 Number 28
Three Four Two Four Five Two Eight

Tag Archives: c++

C++ || How To Convert A String To Upper and Lower Case Using C++

C++ || How To Remove All Whitespace From A String Using C++

C++ || How To Get The File Path, File Name & File Extension From A Path Using C++

C++ || Roman Numeral Conversion – How To Convert Roman Numeral To Integer & Integer To Roman Numeral Using C++

C++ || Telephone Digit Program – How To Convert Letters To Numbers Using C++

C++ || How To Find All Combinations Of Well-Formed Brackets Using C++

C++ || Multi Digit, Decimal & Negative Number Infix To Postfix Conversion & Evaluation

C++ || Snippet – How To Override The Default Signal Handler (CTRL-C)

C++ || Snippet – How To Convert A Decimal Number Into Binary

C++ || Snippet – Simple Linked List Using Delete, Insert, & Display Functions

C++ || Snippet – Custom Template Linked List Sample Code

C++ || Snippet – How To Swap Two Numbers Without Using A Third “Temporary” Variable

C++ || Snippet – Palindrome Checker Using A Stack & Queue

C++ || Convert Numbers To Words Using A Switch Statement

Search

Compile Your Code Now

Translate Page

Popular Pages

Recent

Archives

Categories