I have
const char* one = "q";
const char* two = "p";
If I add the code
const char* temp = two;
two = one;
one = temp;
I can switch the content of 'one' and 'two', but with
void order(const char* first, const char* second)
{
const char* temp = second;
second = first;
first = temp;
}
order(one, two);
I cannot switch them. I'm guessing this is because I am passing the wrong arguments to my function?
Edit: true - those are pointers to const char... and so the pointer itself is not const.
You're trying to change what the pointer points at - the function gets a copy of the contetnt of the original pointers so you need to either have a pointer of pointer or use a reference.
ie:
C
void order( const char **first, const char **second )
{
const char* temp = *first;
*first = *second;
*second = temp;
}
C++
void order( const char *&first, const char *&second)
{}
(the content is the same as your function)
order(pointerA, pointerB) to actually modify the pointers. When they have to do order(&pointerA, &pointerB), it is clear that the function may modify them. So, if you use references, use references to const.The easy solution is
#include <algorithm>
then simply std::swap the two pointers, ie std::swap(first, second).
The slightly harder solution is to write your own swap, and call it order.
void order(const char*& first, const char*& second) {
const char* temp = second;
second = first;
first = temp;
}
note the use of & in the arguments. This means that the arguments are passed by reference, which means that modifications to the pointers will be reflected in modifications to the passed in arguments.
References are a C++ feature that lets you make variables be aliases for other variables.
Your problem is that you confused the map (the pointer) for the territory (the data pointed to), then thought that = on the pointers modified the data. Instead, you made a copy of the maps (the pointers), drew all over them in your function, and then discarded the copies you made after you left your subprocedure.
Because all of the changes (the swapping) was on the copies of the pointers (the duplicate maps), the original pointers (the maps) where left alone.
I'm using "map" and "territory" as a reference to Alfred Korzybski, neither of these words are being used in a programming context, or refer to what is usually called map in C++.
Your code passes only copies of first and second to order. To change first and second, you must pass either references or pointers to them. For references:
void order(const char *&first, const char *&second)
{
const char *temp = second;
second = first;
first = temp;
}
For pointers:
void order(const char **first, const char **second)
{
const char *temp = *second;
*second = *first;
*first = temp;
}
There is also std::swap, available by including <algorithm>:
std::swap(first, second);
Additionally, if the strings were regular arrays rather than string literals, you could pass them as char * instead of const char * and swap the contents of the arrays rather than swapping pointers to them, provided each array were large enough to contain the string in the other.
You're passing the pointers by value and expecting the value of those pointers to be changed inside that function. Similar to passing any variables by value. Pass them by reference as pointed out by others.
Your function get local copies of the pointers. The local copies are in fact switched, but not reflected in the calling functions since their scope ends within the order() function.
You may use strcpy() function to copy the string to a temporary char array and then swap them.
strcpy() because they are const, completely opposite error to the other answer.
constis not the problem.swap, as instd::swap. Second, you passed copies of the pointers into your function, then modified those pointers. Pointers are not the data pointed to, the map is not the territory.constapplies to thecharthat each pointer points to, not to the pointer itself.