我应该在使用数组元素时引用它们吗?
Should I reference elements of arrays when working with them?
假设我们要使用以下代码实现冒泡排序:
void bubbleSort(int arr[], int n){
for(int i=0; i<n-1; i++){
for(int j=i+1; j<n;j++){
if(arr[i]>arr[j]){
swap(arr[i], arr[j]);
}
}
}
}
在swap
函数中arr[i]
和arr[j]
之前是否应该有一个&
,有什么区别?我记得在某处读到不需要在数组元素之前放置 &
符号即可直接使用地址。我知道这是一个愚蠢的问题,所以请原谅我这么问,但是这些细节帮助我更好地理解指针。
template< class T > void swap( T& a, T& b );
这是std::swap()的定义。
如你所见,它获取了元素的地址
Should there be an & before arr[i] and arr[j] in the swap function
取决于 swap
接受的参数类型。
如果您询问的是 C++ 标准库的 std::swap
,那么:不,不应该有运算符 &。
and what would be the difference?
一元&运算符是addressof运算符。结果是指向操作数的纯右值指针。
std::swap
的参数是对非常量的引用,因此不能绑定到右值参数。此外,那将是交换指针;不是元素的值。
你 可以 做 std::iter_swap(&arr[i], &arr[j])
因为 std::iter_swap
间接通过参数迭代器并交换指向的对象......但这会不必要地复杂化。我不推荐这种情况。
或者,std::iter_swap(arr + i, arr + j)
也可以。
一些例子:
// similar to std::swap
void swap1(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
swap1(arr[i], arr[j]);
// similar to std::iter_swap
void swap2(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
swap2(arr + i, arr + j);
swap2(&arr[i], &arr[j]);
函数std::swap
有引用类型的参数。所以这个调用
swap(arr[i], arr[j]);
交换引用对象 arr[i]
和 arr[j]
。
如果你会这样写
swap(&arr[i], &arr[j]);
然后编译器将发出错误,因为您正在传递右值并且您不能将右值与左值引用绑定。
您可以编写自己的 swap
函数,该函数在 C 语言中通过引用接受参数,这意味着当对象通过指向它们的指针间接传递给函数时。
这是一个演示程序。
#include <iostream>
#include <utility>
using namespace std;
void swap( int *px, int *py )
{
int tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int x = 5, y = 10;
cout << "x = " << x << ", y = " << y << '\n';
swap( x, y );
cout << "x = " << x << ", y = " << y << '\n';
swap( &x, &y );
cout << "x = " << x << ", y = " << y << '\n';
return 0;
}
它的输出是
x = 5, y = 10
x = 10, y = 5
x = 5, y = 10
在本次通话中
swap( x, y );
使用了重载的标准函数std::swap
,因为它的参数是左值。
在本次通话中
swap( &x, &y );
之所以称为重载的用户定义函数swap
,是因为它的参数是右值(临时对象),编译器会选择最合适的用户定义函数。
假设我们要使用以下代码实现冒泡排序:
void bubbleSort(int arr[], int n){
for(int i=0; i<n-1; i++){
for(int j=i+1; j<n;j++){
if(arr[i]>arr[j]){
swap(arr[i], arr[j]);
}
}
}
}
在swap
函数中arr[i]
和arr[j]
之前是否应该有一个&
,有什么区别?我记得在某处读到不需要在数组元素之前放置 &
符号即可直接使用地址。我知道这是一个愚蠢的问题,所以请原谅我这么问,但是这些细节帮助我更好地理解指针。
template< class T > void swap( T& a, T& b );
这是std::swap()的定义。
如你所见,它获取了元素的地址
Should there be an & before arr[i] and arr[j] in the swap function
取决于 swap
接受的参数类型。
如果您询问的是 C++ 标准库的 std::swap
,那么:不,不应该有运算符 &。
and what would be the difference?
一元&运算符是addressof运算符。结果是指向操作数的纯右值指针。
std::swap
的参数是对非常量的引用,因此不能绑定到右值参数。此外,那将是交换指针;不是元素的值。
你 可以 做 std::iter_swap(&arr[i], &arr[j])
因为 std::iter_swap
间接通过参数迭代器并交换指向的对象......但这会不必要地复杂化。我不推荐这种情况。
或者,std::iter_swap(arr + i, arr + j)
也可以。
一些例子:
// similar to std::swap
void swap1(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
swap1(arr[i], arr[j]);
// similar to std::iter_swap
void swap2(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
swap2(arr + i, arr + j);
swap2(&arr[i], &arr[j]);
函数std::swap
有引用类型的参数。所以这个调用
swap(arr[i], arr[j]);
交换引用对象 arr[i]
和 arr[j]
。
如果你会这样写
swap(&arr[i], &arr[j]);
然后编译器将发出错误,因为您正在传递右值并且您不能将右值与左值引用绑定。
您可以编写自己的 swap
函数,该函数在 C 语言中通过引用接受参数,这意味着当对象通过指向它们的指针间接传递给函数时。
这是一个演示程序。
#include <iostream>
#include <utility>
using namespace std;
void swap( int *px, int *py )
{
int tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int x = 5, y = 10;
cout << "x = " << x << ", y = " << y << '\n';
swap( x, y );
cout << "x = " << x << ", y = " << y << '\n';
swap( &x, &y );
cout << "x = " << x << ", y = " << y << '\n';
return 0;
}
它的输出是
x = 5, y = 10
x = 10, y = 5
x = 5, y = 10
在本次通话中
swap( x, y );
使用了重载的标准函数std::swap
,因为它的参数是左值。
在本次通话中
swap( &x, &y );
之所以称为重载的用户定义函数swap
,是因为它的参数是右值(临时对象),编译器会选择最合适的用户定义函数。