Member Avatar for nonconformed
nonconformed 0 Newbie Poster 
// function prototype - print accepted transactions
void transAccepted(ofstream&, int&, string&, int&, float&);

// function prototype -  print rejected transactions
void transRejected(ofstream&, int&, string&, int&, string&);

//function call
transAccepted(outputFile, count, accept, weight, cost);

//function call
transRejected(outputFile, count, reject, weight, fill);

//prototype header
void transAccepted(ofstream &outputFile, int &count, string &accept,
                   int &weight, float &cost)
{
    outputFile << setw(3) << count << setw(16) << accept << setw(10)
               << weight << setw(10) << cost << endl;
    outputFile << count << accept << weight << cost << "\n";
}

void transRejected(ofstream &outputFile, int &count, string &reject,
                   int &weight, string &fill)
{
    outputFile << setw(3) << count << setw(16) << reject << setw(10)
               << weight << setw(10) << fill << endl;;
    outputFile <<"\n" << count << reject << weight << fill << "\n";
}

*** Output sample
1 Accepted 1 1.50
1Accepted11.50
2 Accepted 7 9.90
2Accepted79.90
3 Accepted 21 31.90
3Accepted2131.90

// Author: George Franklin - Program 4 Postal Packages
// Student ID: 0245929
// Program Function: Determine cost of package, whether to accept or reject
// package. Send output to a file instead of the screen.

#include <iostream>            // input/output declarations
#include <iomanip>             // i/o manipulator declarations
#include <fstream>            //  needed to use files
#include <string>             // needed to allow strings to be used

using namespace std;



//============================================================================
// Function prototypes
//============================================================================
int calcDimensions(int, int, int, int);
void transAccepted(ofstream&);
void transRejected(ofstream&);
int searchList(int[], int, int);

int main()
{

   int weight,               // variables for package weight
       side1,                   // variables for package dimensions.
       side2,
       side3,
       girth,
       dimension,
       position,
       acceptCount = 0,    // variable to count number of accepted transactions
       rejectCount = 0,    // variable to count number of rejected transactions
       totalRejected = 0,
       totalAccepted = 0,
       count = 0;

   float cost;


   string fill = "-",
          accept = "Accepted",
          reject = "Rejected";

//============================================================================
// Weight Array definition
//============================================================================
  const int arraySize = 15;
  int pkgWeight[arraySize] = {1, 2, 3, 5, 7,
                              10, 13, 16, 20, 25,
                              30, 35, 40, 45, 50};

//============================================================================
// Shipping charge Array definition
//============================================================================
   float shipCharge[arraySize] = {1.50, 2.10, 4.00, 6.75, 9.90,
                                  14.95, 19.40, 24.20, 27.30, 31.90,
                                  38.50, 43.50, 44.80, 47.40, 55.20};
//============================================================================
// Gather shipping data
//============================================================================

        ofstream outputFile;
        outputFile.open("package.txt");
        outputFile << "Trans   Accept/Reject   Weight  Cost \n\n";

     while (weight != -1)
     {
      count++;
      cout <<"\nEnter package weight and 3 dimensions: ";
      cin >> weight >> side1 >> side2 >> side3;

      girth = calcDimensions(weight, side1, side2, side3);
      if (weight > 50 || girth > 60)
      {
         rejectCount++;
         transRejected(outputFile);

      }
      else
      {
        cout <<"Calling Array Search Function. \n";
        cout << fixed << showpoint << setprecision(2);
        position = searchList(pkgWeight, arraySize, weight);
        cost = shipCharge[position];
        cout <<"This is cost $" << cost << "\n" << endl;
        acceptCount++;
        transAccepted(outputFile);

      }

      outputFile <<"Number of accepted packages: " << totalAccepted << "\n"
                  << endl;
       outputFile <<"Number of rejected packages: " << totalRejected << endl;
       outputFile.close();
    }
       return 0;
}
//============================================================================
// prototype header for calculating dimensions
//============================================================================

int calcDimensions(int weight, int side1, int side2, int side3)
{
        int largest, girth;

       if  (side1 >= side2 && side1 >= side3)
        {
                    largest = side1;
        }
        else if (side2 >= side1 && side2 >= side3)
        {
                largest = side2;
        }
        else if (side3 >= side1 && side3 >= side2)
        {
               largest = side3;
        }
        girth = (side1 + side2 + side3 - largest) * 2;
        return girth;
}

//============================================================================
// prototype header for printing accepted transactions
//============================================================================
void transAccepted(ofstream& outputFile)
{
cout <<"I am now in Accept print function. \n";
    float cost;
    int acceptCount = 0,
        weight,
    tcost = static_cast<int>(cost);

    acceptCount++;
    string accept = "Accepted";

    outputFile << fixed << showpoint << setprecision(2);
    outputFile <<"\n" << setw(3) << acceptCount << setw(16) << accept;
    outputFile << setw(4) << weight << setw(8) << tcost << "\n" << endl;
    outputFile <<"\n" << acceptCount << accept << weight << cost;
}

//============================================================================
// prototype header for printing rejected transactions
//============================================================================

void transRejected(ofstream& outputFile)
{
     outputFile.open("package.txt");
     int weight,
         rejectCount;
         rejectCount++;
     string reject = "Rejected",
            fill = " - ";

    outputFile << fixed << showpoint << setprecision(2);
    outputFile << "\n" << setw(3) << rejectCount << setw(16) << reject
                << setw(4) << weight << setw(8) << fill << "\n" << endl;
    outputFile <<"\n" << rejectCount << reject << weight << fill;
}

//============================================================================
// Linear search on an inter array to look up weight and compare for
// shipping price.
//============================================================================
int searchList(int list[], int arraySize, int weight)
{
   cout <<"I am now in Array search function. \n";
   int index = 0;
   int position = -1;
   bool found = false;

   while (index < arraySize && !found)
   {
        if (list[index] >= weight)
        {
            found = true;
            position = index;
        }
        index++;
   }
 cout <<"This is the position " << position << " The index   " << index << endl;
   return position;
}
  • 1 Contributor
  • 0 Replies
  • 79 Views
Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.