Question

MUST WRITE IN C++

Objective: Learn how to design classes using abstract classes and inheritance Assignment: In cryptography, encryption is the process of encoding a message or information in such a way that only authorized parties can access it. In this lab you will write a program to decode a message that has been encrypted using two different encryption algorithms.

Detailed specifications: Define an abstract class that will be the base class for other two classes. It should have: A private member variable of the string type to hold the encrypted message. A constructor that receives the file name as a parameter and reads the text into the object. A pure virtual function decode that will be implemented in the derived classes. A function that prints the message on the screen.

Define two derived classes: CypherA and CypherB. Each one should implement its own version of decode according to the following algorithms:

CypherA should use the following key to decode the message: input character: abcdefghijklmnopqrstuvwxyz decoded character: iztohndbeqrkglmacsvwfuypjx Each 'a' in the input text should be replaced with an 'i', each 'b' with a 'z' and so forth.

CypherB should implement the "rotational cypher" algorithm. In this encryption method, a key is added to each letter of the original text. In order to decode you need to subtract 4. For example:

Cleartext: A P P L E Key: 4 4 4 4 4 Ciphertext: E T T P I

Main Program here
#include
#include
#include

#include "CypherA.h"
#include "CypherB.h"

using namespace std;

int main(int argc, const char * argv[]) {

string filename;

cout << "Enter file name to be decoded with algorithm A: ";
cin >> filename;

class CypherA messageA (filename);

messageA.decode();
cout << "Decoded message: \n";
messageA.print();
cout << endl << endl;

cout << "Enter file name to be decoded with algorithm B: ";
cin >> filename;

class CypherB messageB (filename);
messageB.decode();
cout << "Decoded message: \n";
messageB.print();
cout << endl;

return 0;
}

Answer 1

Below are the complete codes of classes. It is well explained inside the code using classes:

// Cypher.h
#pragma once

#include <string>
#include <fstream>
#include <iostream>
using namespace std;

// abstract class Cypher
class Cypher
{
private:
   string encryptedMessage;
public:
   // constructor recieves file name as parameter
   Cypher(string fileName)
   {
       ifstream file(fileName);   // open file to read

       // if file is open
       if (file.is_open())
       {
           // read content into encryptedMessage
           getline(file, encryptedMessage);
           file.close();
       }
       else
       {
           cout << "Unable to open the file" << endl;
       }
   }

   // Pure Virtual Function
   virtual void decode() = 0;

   // print function
   void print();

   // return the encrypted message
   string getEncryptedMessage()
   {
       return encryptedMessage;
   }
};

********************************************************************************************************************

// CypherA.h
#pragma once
#include "Cypher.h"

class CypherA : public Cypher
{
private:
   string decodedMessage;
public:
   // constructor
   CypherA(string fileName) :Cypher(fileName){}

   // decodes the message
   void decode()
   {
       // decode key
       string key = "iztohndbeqrkglmacsvwfuypjx";

       decodedMessage = "";
       int pos;
       char decodedChar;

       // get encrypted
       string encrypted = getEncryptedMessage();

       // iterate though character by character and decode
       for (int i = 0; i < encrypted.length(); i++)
       {
           // if character is space, append to decoded string as it is
           if (encrypted[i] == ' ')
               decodedMessage += ' ';
           else
           {
               // get position of character
               pos = tolower(encrypted.at(i)) - 'a';

               // get decoded character
               decodedChar = key.at(pos);

               // add to message
               decodedMessage += decodedChar;
           }
       }
   }

   void print()
   {
       cout << decodedMessage << endl;
   }
};

*******************************************************************************************************************

// CypherB.h
#pragma once
#include "Cypher.h"

class CypherB : public Cypher
{
private:
   string decodedMessage;
public:
   // constructor
   CypherB(string fileName) :Cypher(fileName){}

   // decodes the message
   void decode()
   {
       decodedMessage = "";
       int pos;
       char decodedChar;

       // get encrypted
       string encrypted = getEncryptedMessage();

       // iterate though character by character and decode
       for (int i = 0; i < encrypted.length(); i++)
       {
           // if character is space, append to decoded string as it is
           if (encrypted.at(i) == ' ')
               decodedMessage += ' ';
           else
           {
               // subtract 4 position to decode
               decodedChar = toupper(encrypted.at(i)) - 4;

               // if decoded character is less than 'A', rotate it
               if (decodedChar < 'A')
               {
                   decodedChar = 26 + decodedChar;
               }

               decodedMessage += decodedChar;
           }
       }
   }

   void print()
   {
       cout << decodedMessage << endl;
   }
};

Below is the sample output:

This completes the requirement. Let me know if you have any questions.

Thanks!