swap array values in c++

#include <vector>       // needed for vector 
#include <algorithm>    // needed for find
#include <iostream>     // needed for cout, cin 

using namespace std;

// Vectors are just like dynamic arrays, you can resize vectors on the fly

vector<int> a { 1,5,4,6,8 };  // Prepare required vector
int v;

cout << "enter value";  // Read from user
cin >> v;

auto itr = find( a.begin(), a.end(), v);  // Search entire vector for 'v'
if( itr != a.end() ) // If value entered by user is found in vector
{
    a.erase(itr);    // Delete the element and shift everything after element
                     // Toward beginning of vector. This reduces vector size by 1
    a.push_back(0);  // Add 0 in the end. This increases vector size by 1
}

for( int i : a )     // Iterate through all element of a (i holds element)
    cout << i;       // Print i
cout << '\n';        // Line end

a few helpful links: vector , find , iterator , erase , push_back

You could use std::rotate. I suggest that you use std::vector instead of C arrays and take full advantage of the STL algorithms. Nevertheless, below I'm illustrating two versions one with C arrays and one with std::vector:

Version with C array:

#include <iostream>
#include <algorithm> 

int main()
{
int const n = 5;
int a[n] = {1,5,4,6,8};
std::cout << "Enter a Value" << std::endl;
int v;
std::cin >> v;

for(auto i : a) std::cout << i<< " ";
std::cout << std::endl;

auto it = std::find(std::begin(a), std::end(a), v);
if(it != std::end(a)) {
  std::rotate(it + 1, it, std::end(a));
  a[n - 1] = 0;
}

for(auto i : a) std::cout << i<< " ";
std::cout << std::endl;

 return 0;
}

Version with vector:

#include <iostream>
#include <vector>
#include <algorithm> 

int main()
{
std::vector<int> a{1,5,4,6,8};
std::cout << "Enter a Value" << std::endl;
int v;
std::cin >> v;

for(auto i : a) std::cout << i<< " ";
std::cout << std::endl;

auto it = std::find(std::begin(a), std::end(a), v);
if(it != std::end(a)) {
  std::rotate(it + 1, it, std::end(a));
  a.back() = 0;
}

for(auto i : a) std::cout << i<< " ";
std::cout << std::endl;

 return 0;
}

Here's an example using std::array

#include <array>
#include <algorithm>

// defines our array.
std::array<int, 5> a = {{ 1, 2, 3, 4, 5 }};

// find the position of the element with the value 4.
auto where = std::find(a.begin(), a.end(), 4);

// if it wasn't found, give up
if (where == a.end())
  return 0;

// move every element past "where" down one.
std::move(where + 1, a.end(), where);

// fill the very last element of the array with zero
a[ a.size() - 1] = 0;

// loop over our array, printing it to stdout
for (int i : a)
  std::cout << i << " ";

std::cout << "\n";

Why would anyone use these awkward algorithms? Well, there are a few reasons. Firstly, they are container-independant. This will work with arrays and vectors and deques, no problem. Secondly, they can be easily used to work with a whole range of elements at once, not just single items, and can copy between containers and so on. They're also type-independant... you acn have an array of strings, or an vector of ints, or other more complex things, and the algorithms will still work just fine.

They're quite powerful, once you've got over their initial user-unfriendliness.

You can always use either std::array or std::vector or whatever without using the standard library algorithms, of course.

std::array<int, 5> a = {{ 1, 2, 3, 4, 5 }};

size_t where = 0;
int to_remove = 4;

// scan through until we find our value.
while (a[where] != to_remove && where < a.size())
  where++;

// if we didn't find it, give up
if (where == a.size())
  return 0;

// shuffle down the values
for (size_t i = where; i < a.size() - 1; i++)
  a[i] = a[i + 1];

// set the last element to zero
a[ a.size() - 1] = 0;

As a final example, you can use memmove (as suggested by BLUEPIXY) to do the shuffling-down operation in one function call:

#include <cstring>

if (where < a.size() - 1)
  memmove(&a[where], &a[where + 1], a.size() - where);