C++ Homework Help, Project Help, C++ Assignment Solution

C++ is the advanced form of C programming language. It provides facilities for the manipulation of low-level memory and has features of imperative, object-oriented and generic programming. C++ is a general-purpose language used in many fields to execute various tasks. Learning C++ programming language is very technical and after a certain point of time students may feel helpless coping with the many C++ assignments allotted to them by their professor. This is one of the main reasons why we came up with C++ programming assignment help services.

ProgrammingHomeworkHelp.com has been providing its clients with the perfect C++ assignment help to many students trapped in the monotony and stagnation of their homework and assignments. The level of dedication and the range of services we offer comes second to none. Our focus is to build long-term relations with our clients by providing them with the best possible and appropriate C++ solutions. Our C++ homework help platform caters to all topics in C++. So go ahead and approach us with your C++ program homework and leave the burden of finding solutions within the specified time to us.

Learn more about C++ Programming Language

C++ features like performance, efficiency, and flexibility of use are some of the reasons why it is very popular. It is used by programmers in many contexts, with performance-critical applications, software infrastructure, and resource-constrained applications being its key strengths. The language has two main components:

  • A direct mapping of hardware features which are primarily provided by the C subset
  • Zero-overhead abstractions based on those mappings

Developed by Bjarne Stroustrup, C++ inherits most of the syntax from the C language. It supports the following four types of memory management:

  • Automatic storage duration objects
  • Static storage duration objects
  • Thread storage duration objects
  • Dynamic storage duration objects

You can get acquainted with all the essential concepts within C++ programming language like polymorphism, templates, virtual and friend functions, namespaces, and pointers when you request for our C++ online tutoring.

Why you should get help with your C++ assignment, homework or project

  • You may have limited time to focus on your C++ tasks – C++ is so demanding and requires a student to be very committed. You will have to practice on a daily basis to help you grasp the concepts. Getting C++ programming help from ProgrammingHomeworkHelp.com is the best way to relieve yourself from your heavy academic workload. Sometimes the work may be overwhelming and too exhausting. The timeframe allocated for the tasks may also pile more pressure on you. There is a high possibility that you will not do all the assignments perfectly and may jeopardize your grades. That is why we recommend that you let us handle all your straining tasks for you. Do not let other activities force you into a dilemma. You will not be forced into making the hard choice of which tasks to focus on when you choose us to write your assignment.
  • You may lack in-depth knowledge of programming and find the task assigned to you very complex – Learning C++ cannot be done in a day. Availing the help of our C++ coding help experts can furnish your programming skills and make you proficient in all the concepts of C++. We have all the latest technology and resources that your professor wants you to use in your project. Copy pasting online and submitting wrong solutions will definitely earn you low marks. Get immediate C++ help from our reliable and renowned site. Our panel of professional assignment writers is familiar with that topic that is troubling you. You will receive precise and accurate solutions that are well-documented. To help you understand your assignment, comments and pseudo codes which explains the solutions will be included in your content. Contact us when you cannot complete your assignment. We will guide you through the next step to take and provide you with the best solutions.
  • You may not be familiar with the referencing technique and formatting style that your professor wants you to consider when drafting your assignment – You will only score top grades in your programming assignment in C++ if you follow all the guidelines provided by your professor. You may find the requirements confusing and stand no chance of completing the assignment on your own. We are professional assignment providers and our experts are well-versed with all the formatting styles used by top-notch universities across the world. So whether it is MLA, APA, Harvard, Chicago or Vancouver, our talented experts can handle it. You will be impressed with the error-free content you will receive from us. Your professor will congratulate you for a job well done and use you as a good example for other students.
  • If you are fed up of scoring low grades in your C++ assignments – We guarantee consistent top grades to all the students who sign up for our C++ code help. If you want to make a great career in programming and get a lucrative job with top programming companies then you have to be an adept programmer. It is the little things like scoring A+ grade in your assignment that can ensure you graduate with honors. The solutions we deliver are the best and of high quality. You will score top grades when you use our content for your assignment. We will equip you with impeccable programming techniques that will ensure you have the concepts of C++ on your fingertips. You can also make use of the sample papers we have available on our website for free when you want to refer or refine your programming skills.

This is a sample assignment in C++. We can tailor the solutions to your skill level (so advanced, intermediate or basic), just let us know.

Maze Path Finder

You are to prepare a C++ program that accepts one command line argument. This argument
will be the name of a file containing a maze. For example, if the name of your compiled
program is a.out and the name of the maze file is maze1 then you would run the program
as follows.

./a.out maze1

Maze File

The maze file is a text file made up of spaces for pathways, #′s for walls plus one ′s′ and
one ′f′, representing the start and finish of the maze. For the maze to be well formed it must
meet the following requirements

  1. The maze must be surrounded by an unbroken perimeter of #′s. This means there are no
    paths on the inside of the maze leading to the outside.
  2. The start and finish are both inside the maze.
  3. After the final # in each line of the maze the next character is a newline.
  4. There are no spaces within the maze that cannot be reached by moving down one of the
    maze paths.
  5. There are no U shaped mazes. See diagram below.

The following is an example of a well formed maze file.

         ##########
         #  #     #############
    ######  # ### #           ###
    #s       #f### #########   #
    # #### # #     #       ### #
    # #    # ####### ### ###   #
    #   ####         # ###   ###
    ###    ###########     ###
      ####             #####
         ###############

The following points can also be noted about the mazes

  1. The maze can be any width and length and, as you can see, does not have to be
    rectangular.
  2. When moving in the maze you may only move up and down and right and left. You may
    not move diagonally.

The following are examples of U shaped mazes and are not considered well formed.

###  ###        ####### ###
#s#  #f#        #     # #s#
# #### # or     # ### ### #
#      #        #f# #     #
########        ### #######

Such mazes create problems since it’s more difficult to work out what’s the inside and what’s
the outside of the maze.

Program Requirements
Your program must do the following

  1. Load the maze.
  2. Calculate some metrics about the maze.
  3. Print the maze along with the metrics.
  4. Free up all space allocated to the maze.

Please see the Benchmark Program section below to learn exactly how the maze and metrics
are to be displayed.

Maze Data Structure

You can assume that all test cases given to your program will be well formed but you will
need to check for the following problems:

  1. Multiple ‘s’ or ‘f’ in the maze.
  2. ‘s’ or ‘f’ declared outside of the maze.
  3. ‘s’ or ‘f’ not declared at all.
  4. Invalid characters other than spaces, #, s, f or n.

When checking for invalid characters or f or s outside of the maze, you only have to check
left, above and below the maze, not the right side. You will find this will make the assignment
easier to code.

If you find a maze violation you will exit the program printing an error message stating you
are unable to load the maze. Run the benchmark program below to see the exact format of the
message.

PLEASE NOTE. If you have to exit your program for any reason please use exit(0) not
exit(1) or any other number. This is necessary in order for the test program (see below) to
work correctly.

Since the maze can be any size you MUST use STL linked lists to store it. At no stage may
you use arrays within your program to store the maze. Your linked list will have the following
structure. The use of the < and > characters means I′m using doubly linked lists.

row 1<>char<>char<>char<>char<>char<><><>

row 2<><>

As you can see, you have a linked list of rows and each row is a linked list of chars.
Maze Metrics

You will calculate two metrics about the maze:

  1. The total number of branches in the maze.
  2. The total number of dead-ends in the maze.

A branch point occurs when a path in the maze can go in 3 or 4 directions. If it can go in 3
directions we have 1 branch and if it can go in 4 directions we have 2 branches. The only
exception is at the start point of the maze. The number of different directions we can take
from the start point, minus one, is the number of branches. Therefore, we can have anywhere
from 0 to 3 branches emanating from the start.

A dead-end occurs when we have a point in the maze that has only one access path. The only
exception to this is if the finish or start is at a dead end. These are not included in the count.

The following diagrams illustrate.

######               #######                # #                # #                 # #            
#x                      x                #### #              ### ###             ### ###          
######               #######                 x#                 x                   x             
A dead-end at        0 branches at       ######              #######             ### ###          
point x (unless      point x.            0 branches at       1 branch at point     # #            
point x is the       If the point x is   point x.            x.                  2 branches at    
start or finish).    the start of the    If the point x is   If the point x is   point x.         
If the point x is    maze then we        the start of the    the start of the    If the point x is
the start of the     have 1 branch       maze then we        maze then we        the start of the 
maze then we                             have 1 branch       have 2 branches     maze then we     
have 0 branches                                                                  have 3 branches.

In the following example I have placed a digit to represent the number of branches at any fork
in the maze and a d to represent a dead-end.

        ##########
        #d #     #############
    ###### # ###d#           ###
    #s    2 1#f### #########   #
    # #### #     # # 1    d### #
    # #  # ####### ###d###     #
    #  1####       #d###     ###
    ###    ###########1     ###
      ####             #####
         ###############

From this, there are a total of 7 branches (including one from the start) and 5 dead ends.

Hints
To help you use the STL list object I have included a file – exstdlist.cpp – in the
assignment directory on /pub and the DS & A website, which you can compile and run.
Study the code closely as it demonstrates how to use doubly linked lists from the STL.

Benchmark Program

To clarify how the program works, a benchmark executable version has been placed on the
server. You can run it by typing the following command
/home/glingard/maze

To give you an idea of the size of this assignment, the source code for the benchmark
program takes about 380 lines of code, including whitespace and comments.

The output from your compiled program must exactly math that of the benchmark.
In addition, four files – maze1.txt, maze2.txt , maze3.txt and maze4.txt have been
placed in /pub/prprog/assign/assign1 for you to use as tests. The first three mazes
are perfectly valid. The fourth maze has errors you can test for.

Assignment Objectives
The purpose of this assignment is to demonstrate competence in the following skills.

  • Program design
  • Using command line parameters.
  • File handling.
  • Link list manipulation

These tasks reflect all the subject objectives apart from objective 4.
As part of your subject workload assessment, it is estimated this assignment will take 22
hours to complete.

Assignment Errata

It is quite possible that errors or ambiguities may be found in the assignment specification or
the benchmark. If so, updates will be made and announcements made regarding the
amendment. It is your responsibility to keep up to date on such amendments and ensure you
are using the latest version of the Assignment Specification and Benchmark.

#include <iostream>
#include <list>
#include <ctype.h>

using namespace std;

void printList(const list<char> &myList);
void fillList(list<char> &myList, const string &vowels);
void changeCase(list <char> &myList);

void printList(const list<char> &myList)
{
   list<char>::const_iterator itr;

   for (itr = myList.begin(); itr != myList.end(); itr++ ) {
      cout << ' ' << *itr;
   }
   cout << 'n';
}

void fillList(list<char> &myList, const string &vowels)
{
   for (int i = 0; i<vowels.length(); i++) {
      myList.push_back(vowels[i]);
   }
}

void changeCase(list <char> &myList)
{
   list<char>::iterator itr;

   for (itr = myList.begin(); itr != myList.end(); itr++ ) {
      if (islower(*itr)) *itr = toupper(*itr);
      else *itr = toupper(*itr);
   }
}

int main ()
{
  string vowels = "aeiou";
  list<char> myList;

  fillList(myList, vowels);
  printList(myList);
  changeCase(myList);
  printList(myList);

  return 0;
}


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

// load maze from the given file into the list structure
// the height and width of the maze are saved into the out parameters
void load_maze(char *file, list<list<char> > &maze, int &h, int &w);

// check whether the given character is inside the maze
bool inside(list<list<char> > &maze, char c, int h, int w);

// return the character at the given position in the maze.
// if the maze does not have a character at that position,  is returned.
char charAt(list<list<char> > &maze, int x, int y);

// find the position of the given character in the maze
void position(list<list<char> > &maze, char c, int &x, int &y);

void print(list<list<char> > &maze);

int main(int argc, char **argv) {
  // check the argument
  if (argc == 1) {
    cout << "Usage: " << *argv << " <maze file>" << endl;
    exit(0);
  }

  char *file = *(argv + 1);
  int height, width;

  list<list<char > > maze;
  load_maze(file, maze, height, width);

  // check whether s and f are in the maze
  bool in_s = inside(maze, 's', height, width);
  bool in_f = inside(maze, 'f', height, width);

  if (!in_s || !in_f) {
    cout << "'s' or 'f' declared outside the maze" << endl;
    exit(0);
  }

  // valid maze
  // calculate the metrics
  int n_branches = 0;
  int n_deadends = 0;
  // the current position
  int curr_x = 0, curr_y = 0;
  for (list<list<char> >::iterator row = maze.begin();
      row != maze.end(); ++row, ++curr_x) {
    curr_y = 0;
    // move to the first # in this row
    list<char>::iterator it = row->begin();
    while (it != row->end() && *it != '#') {
      ++it;
      ++curr_y;
    }
    while (it != row->end()) {
      if (*it != '#') {
        // calculate the branches at this place
        // how many possible moves around the current position?
        int moves = 
          (charAt(maze, curr_x - 1, curr_y) != '#') +
          (charAt(maze, curr_x + 1, curr_y) != '#') +
          (charAt(maze, curr_x, curr_y - 1) != '#') +
          (charAt(maze, curr_x, curr_y + 1) != '#') ;

        switch (moves) {
          case 1:
            // dead end if *it is not s or f
            n_deadends += (*it != 's' && *it != 'f');
            // *it = 'd';
            break;
          case 2:
            n_branches += (*it == 's');
            break;
          case 3:
            n_branches += 1 + (*it == 's');
            break;
          case 4:
            n_branches += 2 + (*it == 's');
            break;
        }
      }
      ++curr_y;
      ++it;
    }
  }

  // print the maze and metrics
  print (maze);
  cout << "Total number of branches: " << n_branches << endl;
  cout << "Total number of dead-ends: " << n_deadends << endl;

}

void print(list<list<char> > &maze) {
  for (list<list<char> >::iterator row = maze.begin();
      row != maze.end(); ++row) {
    for (list<char>::iterator it = row->begin();
        it != row->end(); ++it) {
      cout << *it;
    }
    cout << endl;
  }
}


bool inside(list<list<char> > &maze, char c, int height, int width) {
  // the position of the character in the maze
  int px = 0;
  int py = 0;
  position(maze, c, px, py);

  // check whether px, py in inside '#'
  bool found;
  found = false;
  for (int i = px - 1; i >= 0; i--) {
    if (charAt(maze, i, py) == '#') {
      found = true;
      break;
    }
  }
  // no # on the north
  if (!found) {
    return false;
  }

  found = false;
  for (int i = px + 1; i < height; i++) {
    if (charAt(maze, i, py) == '#') {
      found = true;
      break;
    }
  }
  // no # on the south
  if (!found) {
    return false;
  }

  found = false;
  for (int j = py - 1; j >= 0; j--) {
    if (charAt(maze, px, j) == '#') {
      found = true;
      break;
    }
  }
  // no # on the west
  if (!found) {
    return false;
  }


  found = false;
  for (int j = py + 1; j < width; j++) {
    if (charAt(maze, px, j) == '#') {
      found = true;
      break;
    }
  }
  // no # on the east
  if (!found) {
    return false;
  }

  return true;
}

void position(list<list<char> > &maze, char c, int &x, int &y) {
  x = 0;
  for (list<list<char> >::iterator row = maze.begin();
      row != maze.end(); ++row, x++) {
    y = 0;
    for (list<char>::iterator it = row->begin();
        it != row->end(); ++it, y++) {
      if (c == *it) {
        // found the character
        return;
      }
    }
  }
}

char charAt(list<list<char> > &maze, int x, int y) {
  if (x < 0 || y < 0) {
    return 0;
  }

  // move to the x row
  list<list<char> >::iterator row = maze.begin();
  for (int i = 0; i < x && row != maze.end(); i++, ++row);

  // x is out of range
  if (row == maze.end()) {
    return 0;
  }

  // move to the y column
  list<char>::iterator column = row->begin();
  for (int i = 0; i < y && column != row->end(); i++, ++column);

  return column == row->end() ? 0 : *column;
}

void load_maze(char *file, list<list<char> > &maze, int &h, int &w) {
  // open the file to read
  ifstream fin(file);
  if (fin.fail()) {
    cout << "could not read file: " << file << endl;
    exit(0);
  }

  // do not skip n and empty space
  fin >> noskipws;

  // push a line into the list
  maze.push_back(list<char>());

  // number of s and f
  int n_s = 0;
  int n_f = 0;

  char c;
  while (fin >> c) {
    if (c == 'n') {
      // the end of the line, push another line
      maze.push_back(list<char>());
    } else {
      // put the character into the current line
      list<char> &curr = maze.back();
      switch (c) {
        case ' ':
        case '#':
          break;

        case 's':
          n_s ++;
          break;

        case 'f':
          n_f ++;
          break;

        default:
          cout << "Invalid characters other than spaces, #, s, f or \n" << endl;
          fin.close();
          exit(0);
      }
      curr.push_back(c);
    }
  }

  // close the file
  fin.close();

  // check the number of s and f
  if (n_s == 0 || n_f == 0) {
    cout << "'s' or 'f' not declared in the maze" << endl;
    exit(0);
  }

  if (n_s > 1 || n_f > 1) {
    cout << "multiple 's' or 'f' declared in the maze" << endl;
    exit(0);
  }

  // check whether the last line is empty
  // if it is then remove it
  list<char> &last = maze.back();
  if (last.empty()) {
    maze.pop_back();
  }

  // calculate the height and width
  h = maze.size();
  w = 0;
  for (list<list<char> >::iterator row = maze.begin();
      row != maze.end(); ++row) {
    if (w < row->size()) {
      w = row->size();
    }
  }
}

Following you should see a sample C++ problem, I’ve had to provide multiple versions of assignments, and can alter the source to match your style.

Beginners have found our C++ homework answers very useful for their assignment problems that are solved by our skilled experts. Many students have availed our C++ assignment help and gave a very positive feedback on our assignment help. Experts have observed that beginners are really hunting for quality and accurate solutions for their C++ assignment questions related to the four pillars of object-oriented development. They are the Encapsulation, Data hiding, Inheritance, and Polymorphism features of object orientation and they look for C++ homework solver at programming homework help.

Banking transaction system

 

Problem:

You have been hired as a programmer by a major bank. Your first project is a small banking transaction system. Each
account consists of a number and a balance. The user of the program (the teller) can create a new account, as well as perform
deposits, withdrawals, and balance inquiries.

Initially, the account information of existing customers is to be read into a pair of parallel arrays–one for account numbers, the
other for balances. The bank can handle up to MAX_NUM accounts. Use the following function to read in the data values:
int read_accts(int acctnum_array[], double balance_array[], int max_accts);

This function fills up the account number and balance arrays (up to max_accts) and returns the actual number of accounts read in
(later referred to as num_accts).

After initialization, print the initial database of accounts and balances. Use function print_accts() described below.
The program then allows the user to select from the following menu of transactions:

Select one of the following:

  • W – Withdrawal
  • D – Deposit
  • N – New account
  • B – Balance
  • Q – Quit
  • X – Delete Account – Extra Credit

Use the following function to produce the menu:

void menu();

This function only displays the menu. The main program then prompts the user for a selection. You should verify that the user
has typed in a valid selection (otherwise print out an error message and repeat the prompt).

Once the user has entered a selection, one of the following functions should be called to perform the specific transaction. At the
end, before the user quits, the program prints the contents of the account arrays.

int findacct(int acctnum_array[], int num_accts, int account);

This function returns the index of account in account_array if the account exists, and -1 if it doesn’t. It is called by all the
remaining functions.

void withdrawal(int acctnum_array[], double balance_array[], int num_accts);

This function prompts the user for the account number. If the account does not exist, it prints an error message. Otherwise, it asks
the user for the amount of the withdrawal. If the account does not contain sufficient funds, an it prints an error message and does
not perform the transaction.

void deposit(int acctnum_array[], double balance_array[], int num_accts);

This function prompts the user for the account number. If the account does not exist, it prints an error message. Otherwise, it asks
the user for the amount of the deposit.

int new_acct(int acctnum_array[], double balance_array[], int num_accts);

This function prompts the user for a new account number. If the account already exists, it prints an error message. Otherwise, it
adds the account to the account array with an initial balance of 0. It returns the new number of accounts.

void balance(int acctnum_array[], double balance_array[], int num_accts);

This function prompts the user for an account number. If the account does not exist, it prints an error message. Otherwise, it
prints the account balance.

void print_accts(int acctnum_array[], double balance_array[], int num_accts);

This function prints all customer information–account number and balance.

 

Source Code:

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

#define MAX_NUM 256

int read_accts(int acctnum_array[], double balance_array[], int max_accts);
void menu();
int findacct(int acctnum_array[], int num_accts, int account);
void withdrawal(int acctnum_array[], double balance_array[], int num_accts);
void deposit(int acctnum_array[], double balance_array[], int num_accts);
int new_acct(int acctnum_array[], double balance_array[], int num_accts);
void balance(int acctnum_array[], double balance_array[], int num_accts);
void print_accts(int acctnum_array[], double balance_array[], int num_accts);

// delete the account, return the remaining number of accounts
int delete_accts(int acctnum_array[], double balance_array[], int num_accts);

int main() {
  int acctnum[MAX_NUM];
  double balances[MAX_NUM];

  // initialize
  int num = read_accts(acctnum, balances, MAX_NUM);
  // display
  print_accts(acctnum, balances, num);

  while (1) {
    char input = 'n';
    // print the menu
    menu();

    // get the user's input, skip empty lines
    while (input == 'n' || input == ' ') {
      cin >> input;
    }
    switch (input) {
      case 'W':
        withdrawal(acctnum, balances, num);
        break;
      case 'D':
        deposit(acctnum, balances, num);
        break;
      case 'N':
        num = new_acct(acctnum, balances, num);
        break;
      case 'B':
        balance(acctnum, balances, num);
        break;

      case 'Q':
        // display the balances before quit
        print_accts(acctnum, balances, num);
        return 0;

      case 'X':
        num = delete_accts(acctnum, balances, num);
        break;
      default:
        cout << ("Unknown selection") << endl;
        break;
    }
   }
}

// create a few bank account.
int read_accts(int acctnum_array[], double balance_array[], int max_accts) {
  acctnum_array[0] = 1;
  acctnum_array[1] = 2;
  acctnum_array[2] = 3;

  balance_array[0] = 1000;
  balance_array[1] = 1000;
  balance_array[2] = 1000;

  return 3;
}

void menu() {
  cout << endl << endl;
  cout << "Select one of the following:" << endl << endl;
  cout << "tW - Withdrawal" << endl;
  cout << "tD - Deposit" << endl;
  cout << "tN - New account" << endl;
  cout << "tB - Balance" << endl;
  cout << "tQ - Quit" << endl;
  cout << "tX - Delete account" << endl;
  cout << endl;
}

int findacct(int acctnum_array[], int num_accts, int account) {
  int i;
  for (i = 0; i < num_accts; i++) {
    if (acctnum_array[i] == account) {
      return i;
    }
  }
  return -1;
}

void withdrawal(int acctnum_array[], double balance_array[], int num_accts) {
  int account;
  int index;
  double amount;

  cout << "Input account number: ";
  cin >> account;
  index = findacct(acctnum_array, num_accts, account);
  if (index == -1) {
    cout << "Account " << account << " does not exsit." << endl;
    return;
  }

  cout << "Input amount of the withdrawal: ";
  cin >> amount;

  if (balance_array[index] < amount) {
    cout << "Account " << account << " does not have sufficient fund." << endl;
  }

  // perform the transaction
  balance_array[index] -= amount;

}

void deposit(int acctnum_array[], double balance_array[], int num_accts) {
  int account;
  int index;
  double amount;

  cout << "Input account number: ";
  cin >> account;
  index = findacct(acctnum_array, num_accts, account);
  if (index == -1) {
    cout << "Account " << account << " does not exsit." << endl;
    return;
  }


  cout << "Input amount of the deposit: ";
  cin >> amount;

  // perform the transaction
  balance_array[index] += amount;

}

int new_acct(int acctnum_array[], double balance_array[], int num_accts) {
  int account;
  int index;

  cout << "Input account number: ";
  cin >> account;
  index = findacct(acctnum_array, num_accts, account);
  if (index == -1) {
    cout << "Account " << account << " does not exsit." << endl;
    return num_accts;
  }


  if (num_accts + 1 == MAX_NUM) {
    cout << "The bank has too many accounts." << endl;
    return num_accts;
  }

  // perform the transaction
  acctnum_array[num_accts] = account;
  balance_array[num_accts] = 0;

  return num_accts + 1;
}

void balance(int acctnum_array[], double balance_array[], int num_accts) {
  int account;
  int index;

  cout << "Input account number: ";
  cin >> account;
  index = findacct(acctnum_array, num_accts, account);
  if (index == -1) {
    cout << "Account " << account << " does not exsit." << endl;
    return;
  }


  cout << "Balance is " << setprecision(2) << fixed << balance_array[index] << endl;
}

void print_accts(int acctnum_array[], double balance_array[], int num_accts) {
  int i;
  cout << setw(12) << "Account" << " " << "Balance" << endl;
  for (i = 0; i < num_accts; i++) {
    cout << setw(12) << acctnum_array[i] << " " << balance_array[i] << endl;
  }
}

// delete the account, return the remaining number of accounts
int delete_accts(int acctnum_array[], double balance_array[], int num_accts) {
  int account;
  int index;

  cout << "Input account number: ";
  cin >> account;
  index = findacct(acctnum_array, num_accts, account);
  if (index == -1) {
    cout << "Account " << account << " does not exsit." << endl;
    return num_accts;
  }


  // move the accounts after the index one position ahead
  while (index < num_accts - 1) {
    acctnum_array[index] = acctnum_array[index + 1];
    balance_array[index] = balance_array[index + 1];
    index = index + 1;
  }

  return num_accts - 1;
}

 

Why ProgrammingHomeworkHelp.com is the best online assignment writing provider

There are many aspects that make us the best in the field of providing assignment help. Every single day we come in to save the day for all students who find it hard to understanding various topics in C++. We are not novices in this field. We have been doing an exceptional job for more than ten years now. Our clients hold our service in high esteem and have been sending us positive reviews. They acknowledge the good work we are doing and always come to us whenever they have a problem with their programming homework. Almost 90% of our clients recommend our services to their classmates and friends.

Our Panel of experts

 The experts who will handle your assignment are very proficient and highly qualified. They hold Masters Degrees and PhDs in Computer Science from highly recognized universities. They are equipped with in-depth experience and have helped thousands of students from diverse locations. You can rest assured that all your tasks will be handled by the best in the business. We test our experts thoroughly before hiring them. They have to prove their academic credentials and prove that they are the best.

 

Our Panel of experts also consists of former professors who have taught programming to students. They are familiar with what to look out for when marking an assignment. They will include all factors that make up a perfect content on your work and ensure you score top grades.

Our Clients

 We provide help to students based in almost all countries across the world.  Our service is available in countries such as USA, UK, Canada, Australia, Singapore, Middle East, Malaysia etc. We provide around the clock service and support to our clients. You can send us an email or place your order at any time. It doesn’t matter how late it is. We have experts from all countries across the world. So when you contact us late in the night, you will find an expert who is just beginning or in the middle of his/her workday.

 We cater to all assignments and homeworks that are related to C++.  We can handle any project no matter how difficult your assignment is. Placing an order on our site is effortless. You only need to follow four simple steps and you will be good to go.

  1. Send us your assignment – Submit to us your details by filling in the form on our website. You will be prompted to attach your assignment and the requirements you want to be followed. Your guideline should be very detailed and precise.
  2. We will receive your assignment, go through it and come up with a quote –We will do a research on your assignment to establish its level of complexity and the time it would take. These factors will determine the amount you are supposed to pay for our service.
  3. Receive your quote and make payment – We will send you the quote in your inbox for payment. You can make use of your preferred payment method that is accepted by our site. You can pay by PayPal or credit/debit cards.
  4. Receive a well-drafted content that meets your requirements – Our experts will embark on your task immediately after we have confirmed your payment. They will write your content from scratch and put all your requirements into considerations. Your work will be delivered within the stipulated time.

 

Do not let the frustrations of your academic tasks get to you. We can change your attitude towards programming no matter how poor you are in the subject. Students like you who were poor in C++ programming only typed “do my C++ assignment” and our experts have helped them improve their grades. They are now very confident and look forward to every programming class. Your case will not be any different. We have a C++ live code help where you only need to write “make my C++ assignment” and our customer support team will link you to a professional tutor.

Sometimes you may not understand what your professor is teaching in class. You may also be forced to miss a class session by inevitable events such as falling ill. Our experts will guide through what you missed and put you on par with your classmates.  It is not every student who will grasp the concepts on the first attempt. Some will require the concept to be repeated before they finally understand it. We know your professor cannot do this for you. The time allocated for your coursework does not allow the professor to focus on the weak students and repeat a concept.

The only place you can get such attention is on our site. We have all the time to walk you through all the concepts you do not understand. Our experts are very friendly and approachable. You can ask them all your questions that couldn’t be answered in class. This is a suitable platform for shy students who are intimidated by the high number of students in their class. We can help such students build their self-esteem and score better grades.

Since we are available online, you do not need to meet our experts at some place. We bring learning to you at your own convenience and at the comfort of your home. Unlike an offline tutor who would charge you more and ask you to make an appointment first before getting help, you do not need to wait for a scheduled date to avail our service.

We are committed to ensuring you get nothing but the best when you pay for help with C++ project on our website. We will help you deliver a magnificent presentation that will leave a mark on the panel of professors who are awarding marks. We can assure you that you will accomplish immaculate outcomes through our supreme help. As an established site, we offer the following benefits to students:

  • Confidentiality of personal information – All the information you send to us will be kept safe on our website. We value your privacy and do not sell or trade our clients’ details with third parties.
  • 24/7 Customer support service – We have a team of customer support executives who are available round the clock ready to assist you with your queries. Suppose you are a new client and finding it hard to place an order, they will explain everything to you and help you with everything. Our experts will only link you to an expert who can handle your assignment best. How a site interacts with its clients speaks volume about their service. We ensure that you have a memorable service. We are certain that the courteous nature of our customer support team will retain you as our client.
  • Top quality codes and solutions– There is nothing more frustrating in programming than a code that is returning errors. Any single mistake in a code will definitely lead to errors. It becomes even more difficult for the student if he doesn’t know how to debug the error. We are C++ gurus and are familiar with the code rules that must be followed for the program to be error-free. Our experts will save you from the frustrations and stress you go through when struggling with coding. In case your assignment is theory in nature, we do proofreading and spelling check to eliminate all grammatical errors. We check every content if it meets the set standards before submitting it to the client. We never compromise on quality like some sites just to complete your work. Our experts are dedicated to ensuring all your requirements are satisfied. Students who have availed our services usually have no reason to complain or worry. You can go to our review page or check the samples of assignments we have done to confirm this.
  • On-time delivery guarantee – Our experts were once students and they know how important a deadline is for students. Submitting your assignment late can make you lose marks in your assignment. When you place an order with us, you do not have to be stressed by your short deadlines. You only sit back, relax and wait for the due date. We always meet our deadlines. Our site is very ethical and does not make false promises. Once we have agreed with a client on a stipulated date then the solutions will be sent on that date. Do not wait till it is too and you are overwhelmed. Contact us immediately the assignment has been allotted to you. We know that most students are procrastinators and love to do things at the last minute. This is a very bad habit that may prove costly to you. Send us your tasks and let us help you carry your academic burdens. After placing your order, make use of our assignment tracker facility and see the progress of your assignment.
  • 100% original content – Plagiarism is a vice. It may seem like an easy way out but it has negative repercussions. You may fail in your assignment or be made to repeat the task. Do not fall into this temptation when your assignment is too difficult for you to handle. Get in touch with us as soon as possible. We will provide you with plagiarism-free solutions. We can guarantee that our content has no traces of plagiarism because we use a checker-software that determines if the content has been copy-pasted online. Most students don’t have this tool and therefore may risk submitting plagiarized content if they don’t get help from us.
  • Our content is charged a fair rate – it is not just about the money for us. Our main priority is satisfying our clients. Since most of our clients are students, we came up with economical rates that suit them. Many students do not have permanent jobs that can fend for their expenses. They, therefore, have limited income. Our service strives at providing a mix of top quality content and fair price which is what students are looking for. We assure you that the amount you will pay for our service will not strain your pocket. We also offer great discounts as a reward to our loyal clients. If you want to be eligible for one then use our service repeatedly.
  • Unlimited revisions for free on the content we write for our clients – As we mentioned earlier, our main priority is your satisfaction. We want to ensure that the service you have received from us has exceeded your expectations. We know that our experts are equal to any C++ assignment writing task and will always deliver what is expected. However, sometimes even the best make mistakes and you may need your content to be tuned. In those unlikely circumstances, we will do a free revision on your work until you are completely satisfied. Nonetheless, this will depend on the guidelines you had submitted earlier together with your assignment. You should not make any changes to the guidelines after you have received your content. The free unlimited revision policy will not apply if you do. Instead, your request will be considered as anew order and you will be required to make payment.

We want to help you achieve your dream of scoring top grades in your programming class. Send us an email on info@ProgrammingHomeworkHelp.com or chat with our customer support executives if you need more clarification.