C++ 通过参考c++；

这里不使用引用调用有什么特别的原因吗

AFAIK引用调用应该更快，占用更少的内存

<我的C++老师告诉我，如果不改变函数中数组的任何内容，只引用引用调用。< /P> 当您不更改函数内部的内容时，应使用该函数或您更改了内容，并希望将更改反映到原始数组中或不关心要反映到原始数组中的更改

---

如果您不希望函数更改原始数组（调用后需要保留原始值），并且被调用方函数更改传递参数的值，则不应使用该函数。

通常，在入门课程中，它们会告诉您，这样您就不会意外更改不希望更改的内容

---

例如，如果您通过引用传入用户名，并意外地将其更改为mrsbuxley，这可能会导致错误，或者至少会在以后造成混淆。

您的老师错了。如果您需要修改数组，可以使用“按引用传递”。如果不想修改某些内容，请按常量引用传递。

我看不出有任何理由不能按引用传递。或者，您可以传递指针，但我认为通过引用传递有时会更好，因为它可以避免空指针异常

void function(int array[])
{
    std::cout << array[0] << '\n';
}

// somewhere else..
int array[2] = { 1, 2 };
function(array); // No copy happens here; it is passed by reference

---

如果你的老师认为这是一种惯例，那么如果有必要的话，可以随意打破它。您始终可以在函数上方的注释中记录此操作。

为防止意外更改，请使用pass by const reference；这样，默认情况下*，传入的数组不能被调用的函数更改

---

*可以使用

常量转换覆盖
如果满足以下条件，则可以通过引用传递：

您不会修改传递的对象
您想修改对象，但不想保持旧对象不变
当您通过引用传递某个内容时，只有指针被传递给函数。如果传递整个对象，则需要复制它，这样会消耗更多的cpu和内存。
请稍等。。我害怕人们如何回答这个问题。据我记忆所及，数组总是通过引用传递的

void function(int array[])
{
    std::cout << array[0] << '\n';
}

// somewhere else..
int array[2] = { 1, 2 };
function(array); // No copy happens here; it is passed by reference

那你是什么意思

此外，许多人认为只有在修改函数中数组的内容时才应该这样做。那么，对const的引用呢

void function(const int arr[])
{
    std::cout << arr[0] << '\n';
}

void函数（const int arr[]
{
std:：cout一般来说，对象应该始终通过引用传递。否则将生成对象的副本，如果对象很大，这将影响性能

现在，如果您正在调用的方法或函数没有修改对象，最好按如下方式声明函数：

void some_function(const some_object& o);

如果试图修改函数体中对象的状态，则会生成编译错误

还应该注意，数组总是通过引用传递。
除了所有关于何时以及如何通过非原语类型的const引用传递的常见讨论之外，数组在这里非常特殊

void function(int array[])
{
    std::cout << array[0] << '\n';
}

// somewhere else..
int array[2] = { 1, 2 };
function(array); // No copy happens here; it is passed by reference

由于与C的向后兼容性，并且由于特定的问题：数组可能很大，数组在C或C++中从不被值传递。数组将衰减为第一个元素的指针，因此当你写：
void foo( type array[100] );

编译器实际上正在处理：

void foo( type *array );

不管数组的大小如何（这里有两个常见的陷阱：相信
array
是
foo
中的一个数组，并且相信它上保证有100个元素

现在，C++中实际上可以通过引用传递数组，但是引用必须是数组的具体类型，包括大小：
void foo_array( type (&array)[100] );

有趣的语法告诉编译器，函数将采用100个类型为
type
的元素数组。其优点是编译器可以为您执行大小检查：

// assuming 'type' is defined
int main() {
   type array0[99];
   type array1[100];

   foo( array0 );     // compiles, but if size=100 is assumed it will probably break
                      // equivalent to: foo( &array0[0] )
   // foo2( array0 ); // will not compile, size is not 100
   foo2( array1 );    // compiles, size is guaranteed to be 100
}

现在的问题是，您的函数只适用于正好包含100个元素的数组，并且在某些情况下，您可能希望在不同的数组大小中执行相同的操作。这两种解决方案是：以数组大小对函数进行模板化，这将为每个使用的大小提供大小安全的实现—更大的编译时间和bi如果是二进制大小，则为每个不同的大小编译模板——或者使用传递值语法，这将使数组衰减——大小不安全，必须作为额外参数、较小的编译时间和二进制大小进行传递。第三个选项将两者结合使用：

void foo( type *array, int size );
template <size_t N>
void foo( type (&array)[N] ) {
   foo( array, N );
}

void foo（类型*数组，整数大小）；
模板
void foo（类型和数组）[N]）{
foo（数组，N）；
}

在这种情况下，虽然每个大小都有一个模板化的
foo
，但编译器很可能会内联调用，生成的代码将相当于提供数组和大小的调用方。不需要额外的计算，并且对实际数组的类型安全

现在，通过引用传递很少与数组一起使用。
我们的房子风格是从不通过值传递对象，而是始终传递引用或常量引用。我们不仅拥有可以包含100 MB数据的数据结构，通过值传递将是应用程序杀手，而且如果我们通过值传递3D点和向量我们的应用程序将陷入停顿。
通过引用传递对象始终是一个不错的选择，但我们需要小心，首先我们必须确定我们的功能目的是什么

你有
double get_discounted_amount(const double &amount,double discount){
    return (amount*discount/100);
}