在某些情況下，參考傳遞會衰減為指標傳遞嗎？

我一直在尋找這個問題的答案，但我似乎找不到任何東西，所以我在這里問：

參考引數是否會衰減為邏輯上必要的指標？

讓我解釋一下我的意思：

如果我宣告一個參考 int 作為引數的函式：

void sum(int& a, const int& b) { a  = b; }

（假設這不會被行內）

合乎邏輯的假設是呼叫這個函式可以通過不傳遞任何引數來優化，而是通過讓函式訪問已經在堆疊上的變數。直接更改這些可以防止需要傳遞指標。

問題在于（再次假設這不會被行內），如果從大量不同的地方呼叫該函式，則每個呼叫的相關值可能位于堆疊中的不同位置，這意味著呼叫可以'沒有被優化。

這是否意味著，在這些情況下（如果從代碼中的大量不同位置呼叫函式，這可能構成大多數情況），參考衰減為指標，該指標被傳遞給函式并使用影響外部范圍內的變數？

額外的問題：如果這是真的，這是否意味著我應該考慮在函式體內快取參考的引數，這樣我就可以避免傳遞這些參考所帶來的隱藏的取消參考？然后我會保守地訪問實際的參考引數，只有當我需要向它們實際寫入一些東西時。如果認為取消參考的成本高于復制一次的成本，這種方法是否有保證，或者最好相信編譯器為我快取這些值？

獎金問題代碼：

void sum(int& a, const int& b) {
    int aCached = a;
    // Do processing that required reading from a with aCached.
    
    // Do processing the requires writing to a with the a reference.
    a  = b;
}

額外獎勵問題：假設（假設以上所有內容都是真的）是否安全，當傳遞“const int& b”時，編譯器將足夠聰明，可以在傳遞指標不夠高效時按值傳遞 b？我背后的理由是“const int& b”的值是可以的，因為你從不嘗試寫入它，只讀取它。

uj5u.com熱心網友回復：

編譯器可以決定將參考實作為指標、行內或它選擇使用的任何其他方法。就性能而言，這無關緊要。在優化方面，編譯器可以并且將會做任何它想做的事情。如果需要，編譯器可以將您的參考實作為按值傳遞（并且在特定情況下這樣做是有效的）。快取結果無濟于事，因為編譯器無論如何都會這樣做。如果你想明確地告訴編譯器這個值可能會改變（因為另一個執行緒可以訪問同一個指標），你需要使用關鍵字 volatile （或者 std::atomic 如果你還沒有使用 std： ：互斥）。如果您不使用關鍵字 volatile，編譯器幾乎肯定會為您快取結果（如果合適）。然而，有

1. 獲取臨時值（右值）的地址（指標）是 C 中的未定義行為。
2. 參考是不可變的，有時需要包含在 std::ref 中。

在這里，我將提供兩種差異的示例。

使用參考的此代碼有效：

static int do_stuff(const int& i)
{
}
int main()
{
  do_stuff(5);
  return 0;
}

但是這段代碼有未定義的行為（實際上它可能仍然有效）：

static int do_stuff(const int* i)
{
}
int main()
{
  do_stuff(&5);
  return 0;
}

那是因為獲取臨時值（非左值）的地址在 C 中是未定義的行為。不保證該值具有地址。請注意，像這樣獲取地址是有效的：

static int do_stuff(const int& i)
{
  const int *ptr = &i;
}
int main()
{
  do_stuff(5);
  return 0;
}

因為在函式 do_stuff 內部，變數有一個名字，因此是一個左值。這意味著當它在 do_stuff 內部時，它保證有一個地址。

所以這是 C 中指標和參考之間的一個區別。還有另一個區別，那就是常量性/不變性。

在 C 中需要了解的重要一點是輔助函式 std::ref 的使用。考慮以下代碼：

#include <functional>
#include <thread>
#include <future>
#include <chrono>
#include <iostream>

struct important_t
{
  int val = 0;
};

static void work(const volatile important_t& arg)
{
  std::cout << "Doing work..." << std::endl;
  std::this_thread::sleep_for(std::chrono::seconds(3));
}

int main()
{
  important_t my_object;
  {
    std::cout << "Starting thread" << std::endl;
    std::future<void> t = std::async(std::launch::async, work, std::ref(my_object));
    std::cout << "Waiting for thread to finish" << std::endl;
  }
  
  return 0;
}

上面的代碼可以很好地編譯，并且是完全有效的 C 代碼。但是如果你這樣寫：

std::future<void> t = std::async(std::launch::async, work, my_object);

它不會編譯。那是因為 std::ref。代碼在沒有 std::ref 的情況下無法編譯的原因是函式 std::async（以及 std::thread）要求作為函式引數傳遞的每個物件都是可復制構造的。這證明了 C 中參考和所有其他內置型別之間的根本區別。參考是不可變的，并且無法使它們可編輯。考慮以下代碼：

#include <iostream>
int main()
{
  // Perfectly valid
  // Prints 5
  {
    int val = 0;
    int& val_ref = val;
    val_ref = 5;
    std::cout << val << std::endl;
  }
  // Compiler error:
  // A reference must always be initialized.
  // A reference will always point to the same value throughout its lifetime.
  {
    int val = 0;
    int& val_ref;
    val_ref = val;
    val_ref = 5;
    std::cout << val << std::endl;
  }
  // We will encounter a similar compiler error with a const pointer:
  // A const value must always be initialized.
  // A const pointer will always point to the same value throughout its lifetime.
  {
    int val = 0;
    int *const val_ptr;
    val_ref = &val;
    val_ref = 5;
    std::cout << val << std::endl;
  }
  return 0;
}

這導致得出這樣的結論，即參考與 C 中的指標不同。它幾乎與 const 指標相同。只是一點點澄清：

指向 const int 的 const 指標：

void do_stuff(const int *const val)
{
  int i;
  val = 5; // Error
  val = &i; // Error
}

指向 int 的 const 指標：

void do_stuff(int *const val)
{
  int i;
  val = 5; // Allowed. The int is not const.
  val = &i; // Error
}

指向 const int 的指標：

void do_stuff(const int* val)
{
  int i;
  val = 5; // Error
  val = &i; // Allowed
}

C 中的 int 參考與指向 int 的 const 指標最接近。int 是可編輯的，指標不是。

標籤：C 指针 参考

上一篇：如何訪問一個16位變數作為兩個8位變數？和兩個8位變數作為一個16位變數

下一篇：在頭檔案中定義函式是否不當？