17

I have two arrays of pointers to doubles that I need to swap. Rather than just copy the data within the arrays, it would be more efficient just to swap the pointers to the arrays. I was always under the impression that array names were essentially just pointers, but the following code receives a compiler error:

double left[] = {1,2,3};
double right[] = {9,8,7};

double * swap = left;
left = right; // Error "ISO C++ forbids assignment of arrays"
right = swap; // Error "incompatible types in assignment of `double*' to `double[((unsigned int)((int)numParameters))]'"

Creating the arrays dynamically would solve the problem, but can't be done in my application. How do I make this work?

Improve this question
7
  • Array name is not a pointer. Array name is an address of its first element. Commented Aug 3, 2010 at 4:17
  • 2
    Whereas a pointer is an address to a variable. Why can't I swap those addresses? Commented Aug 3, 2010 at 4:29
  • 2
    @thornate: The most relevant difference between an array name and a pointer variable is that an array name is not an lvalue, therefore it cannot be the target of an assignment statement. So the way to do what you want is to assign the array names to pointer variables, which are lvalues, then swap those. There's no way to make "left" or "right" point to anything else, once they've been defined. Commented Aug 3, 2010 at 4:37
  • @thornate pointer's value is an address to the variable. The pointer name itself does not denote address like in the case of arrays (you have to use operator & to get the addresss of a pointer). During pointer assignments one pointer's value is taken and assigned to another pointer. You can't do that on arrays because, by the language concept, they denote adresses itself. According to this, you are trying to do something like 0x23ff10 = 0x23ff44 assuming that left is 0x23ff10 and right is 0x23ff44. Commented Aug 3, 2010 at 9:57
  • @thornate: "I have two arrays of pointers to doubles"??? Where? You don't have any "arrays of pointers" in your code. Commented Aug 3, 2010 at 14:50

7 Answers 7

Reset to default
15 
double array_one[] = {1,2,3};
double array_two[] = {9,8,7};

double *left = array_one;
double *right = array_two;

double * swap = left;
left = right;
right = swap;

Works nicely.

edit: The definitions array_one and array_two shouldn't be used and the double*left and double*right should be as public as your original left and right definitions.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

It only works nicely if I want to use left and right after that point; I actually need to swap array_one and array_two, so that they're also swapped in the function that called this one.
@thornate there's no function in your question example. Maybe it could be solved by passing pointers to a function? But it would be better if you could edit your post and explain what exactly you are trying to accomplish.
It doesn't always seem to work. std::swap() is a much better option in C++.
13

Arrays are not the same as pointers and cannot be swapped in the way you describe. To do the pointer swap trick, you must use pointers, either dynamically allocate the memory, or use pointers to access the data (in the way Daniel has described).

Improve this answer

2 Comments

Arrays are not pointers. Arrays are not pointers. Arrays are not pointers. +1
Speaking of dynamically allocating the memory, you could use std::vector, which has a swap() method for swapping the underlying pointers.
8

C-style arrays are not pointers, but like most objects, they can be swapped with the standard std::swap():

#include <iostream>
#include <utility>
int main()
{
        double array_one[] = {1,2,3};
        double array_two[] = {9,8,7};
        std::swap(array_one, array_two);
        std::cout << "array_one[0] = " << array_one[0] << '\n';
        std::cout << "array_two[0] = " << array_two[0] << '\n';
}

Actually, looks like std::swap() for arrays is only defined in C++0x (20.3.2), so nevermind. The correct answer is, for both arrays in scope and arrays as pointers to first elements:

 std::swap_ranges(array_one, array_one + 3, array_two);
Improve this answer

1 Comment

Best and the most simple answer here.
2

One of the easiest ways to convince people that they're not pointers, and not easily swapped, is to show the following code:

struct ex {
  char c[4];
  double d[3];
};
struct ex a = {"foo", {1.0, 2.0, 3.0} };
struct ex b = {"bar", {6,7,8} };

Now clearly a.d and b.d are arrays. Swapping them will involve hard work, as the array {6,7,8} has to end in memory after a.c=="foo" and that means copying 3 doubles. There's no pointer in the picture.

Improve this answer

Comments

0

Try this

double *right = (double[]){9,8,7};
double *left = (double[]){8,2,3};
Improve this answer

2 Comments

I can't change the way the arrays were created; they're passed to the function I'm creating and I can't edit the way they were defined.
This syntax is a C99 feature which is not in C++
-1

You can pass both pointers to arrays by references, and in case pointers are not const, you can just swap them:

void swap(char * & first, char * & second)
{
     std::swap(first, second);
}
Improve this answer

Comments

-3

When you declare an array, the name is a pointer, which cannot be altered.

Ex:

int array[10];
int *p;

p = array; // legal
array = p; // illegal; array is a constant pointer which can't be altered.

The only way you can achieve the swap is using new pointers to the array.

This should help you:

SO question on array name as pointer

Improve this answer

1 Comment

sizeof(array) will prove that array is not a pointer. But it converts into a pointer when you need one.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.