c++ - Chuyển tiếp tham chiếu: trả về T khi được cung cấp T&& và T& khi được cung cấp T&

In lại Tác giả: Walker 123 Thời gian cập nhật: 27-11-2023 23:47:55 29 4

A& xinh đẹp(A&x)
{
    /*làm cho x đẹp*/
    trả lại x;
}

Một người đẹp(A&& x)
{
    /*làm cho x đẹp*/
    trả lại x;
}

void read_A(const A& x) { /* ... */ }
void take_A(A&& x) { /* ... */ }

Một x();
read_A(đẹp(x));
take_A(đẹp(A()));

mẫu
std::enable_if_t<>::value>
/*???*/ khá(T&& x)
{
    /*làm cho x đẹp*/
    trả về x; //?
}

#include 

mẫu 
T somefunc(T&& a) {
  /* làm gì đó với dấu */
  std::cout << __PRETTY_FUNCTION__ << '\n';
  trả về std::forward(a);
}

int main(int argc, char* argv[]) {
  int a = 5;

  somefunc(a);
  một số chức năng (5);

  trả về 0;
}

T somefunc(T &&) [T = int &]
T somefunc(T &&) [T = int]

#include 
#include 

mẫu  T somefunc(T &&a) {
  /* làm gì đó với dấu */
  std::cout << __PRETTY_FUNCTION__ << '\n';
  trả về std::forward(a);
}

mẫu 
                       std::is_same::type, float>::value,
                       int>::loại = 0>
T onlyfloat_core(T &&a) {
  /* làm gì đó với dấu */
  std::cout << __PRETTY_FUNCTION__ << '\n';
  trả về std::forward(a);
}

mẫu 
          tên kiểu std::enable_if<>::value, int>::type = 0>
T onlyfloat_wrong(T &&a) {
  /* làm gì đó với dấu */
  std::cout << __PRETTY_FUNCTION__ << '\n';
  trả về std::forward(a);
}

int main(int argc, char *argv[]) {
  int a = 5;
  const float b = 5;

  somefunc(a);
  một số chức năng (5);

  onlyfloat_core(b);
  // onlyfloat_wrong(b);

  trả về 0;
}

29 4 0

• Không thể lấy từ Func Chuyển đổi sang Func

  Tôi đang bối rối về lỗi này: Không thể chuyển đổi hoàn toàn loại 'System.Func [c:\Program Files (x86)\Reference Assemblies\

• rỉ sét - Triển khai phổ biến tất cả T, &T, &mut T, [T], &[T], *mut T

  Hãy xem xét mã này: pub trait Hello { fn hello(&self); } impl Hello for Any { fn hello(&self) {

• "T t = {};" và "T t{};" có thể tạo ra kết quả khác nhau không?

  Vấn đề rất đơn giản. Có thể xây dựng một kiểu T sao cho hai khai báo biến bên dưới sẽ cho ra các kết quả khác nhau không? T t1 = {}; T t2{}; Tôi đã nghiên cứu cppreference và tiêu chuẩn trong hơn một giờ và tôi hiểu những điều sau:

• không thể áp dụng so sánh(T,T) trong Bộ so sánh cho (T,T)

  Ý tưởng Intellij mang lại cho tôi lỗi này: "Không thể áp dụng so sánh (T, T) trong Bộ so sánh cho (T, T)" cho mã sau: lớp công khai

• php -\n\t\t\t\t\Ý nghĩa và cách sử dụng trong php là gì

  Bất cứ ai có thể cho tôi biết ý nghĩa và cách sử dụng: n\t\t\t\t\n\t\t\t trong phản hồi sau đây từ và dwr service. \n\t\t\t

• Sự khác biệt giữa "T a", "T a()" và "T a=T()", trong đó T là một lớp là gì?

  Cho T là một lớp C++. Có sự khác biệt nào trong hành vi giữa ba hướng dẫn sau không? Thực tế là T a; T a(); T a = T(); T có cung cấp định nghĩa rõ ràng cho một hàm tạo không có tham số có làm thay đổi câu hỏi theo bất kỳ cách nào không? Câu hỏi tiếp theo: Điều gì sẽ xảy ra nếu

• Con trỏ thông minh trong Rust: BoxRcvòng cungTế bàoRefCellYếu đuối

  Con trỏ thông minh trong Rust là gì? Con trỏ thông minh là một loại cấu trúc dữ liệu là con trỏ có quyền sở hữu dữ liệu và chức năng bổ sung. Sự phát triển xa hơn của con trỏ Một con trỏ là một vị trí bộ nhớ chứa

• Cách đơn giản nhất để sắp xếp một mảng luân phiên là gì (ví dụ: T, T,F,F,F,T,F,T,F,F,F đến T,F,T,F,T,F,T, F ,T,T,T)?

  Ví dụ: tôi có một vectơ vectơ > v={{true,1},{true,2},{false,3},{false,4},{false,5},{true,6},{false ,7 },{true,8

• Python 3 Pandas - các cột có thêm \n\t\t\t\t\t

  Tôi có một khung dữ liệu từ bảng tính .xls, tôi đã in các cột bằng print(df.columns.values) và đầu ra chứa một cột có tên: Phản hồi thăm dò ý kiến\n\t\t\t\t\t. Tôi đã kiểm tra Excel

• Tại sao Stream.reduce lại sử dụng BinaryOperator thay vì BiFunction ?

  Câu hỏi này đã có câu trả lời ở đây: Lý do chính đáng để chọn tính bất biến trong API như

• rỉ sét - Sự khác biệt giữa &T và T/&, ~T và T/~

  Sự khác biệt giữa loại con trỏ làm tiền tố loại và dấu gạch chéo ở phía trước loại làm hậu tố. Chính xác thì dấu gạch chéo có nghĩa là gì? Câu trả lời hay nhất Cú pháp T/~ và T/& về cơ bản không được dùng nữa (Tôi thậm chí không chắc liệu trình biên dịch có còn chấp nhận nó hay không). Trong giai đoạn đầu của quá trình chuyển đổi sang sơ đồ vectơ mới, [T

• Cách lấy T* từ tham số mẫu T, T& hoặc T*

  Tôi đang cố gắng tìm cách lấy lớp cơ sở cho các tham số mẫu. Hãy xem xét lớp sau: template class Foo { public: Foo(){}; ~Foo(){};

• std::is_trivially_constructible khi T được khai báo là T::T(T&)Kết quả không chính xác cho ::value

  Đây là một câu hỏi nhỏ làm tôi bối rối. Tôi không biết mô tả nó như thế nào, vì vậy chỉ cần nhìn vào đoạn mã sau: struct B { B() {} B(B&) { std::cout ::value #include

• Công dụng của T::T(T&) là gì?

  Tại sao T::T(T&) và T::T(const T&) phù hợp hơn để sao chép? (Có lẽ được sử dụng để triển khai ngữ nghĩa di chuyển ???) Mô tả gốc (đã được chứng minh là sai bởi melpomene): Trong C++ 11, một tính năng mới

• Nhập tham số T bằng Eclipse trong Loại ẩn T trong T[] toArray(T[] a)

  Tôi nhận được cảnh báo khi sử dụng Eclipse 4.2 trong Java 7 và cố gắng triển khai phương pháp sau của giao diện Danh sách. công khai T[] toArray(T[] a) { ret

• foo[T](T,T) : Phần mở rộng/suy luận kiểu Scala của T

  Giả sử có ba hàm: def foo[T](a:T, b:T): T = a def test1 = foo(1, "2") def test2 = foo(List(), ListBuffer()) Mặc dù

• generics - Thống nhất loại chung: nhiều tham số (T, T) so với nhiều danh sách tham số (T)(T)?

  Tôi hơi bối rối về sự khác biệt trong việc kiểm tra kiểu giữa các hàm chung Currying và không Currying: scala> def x[T](a: T, b: T) = (a == b ) x: [T]( Tại,

• c++ - Chuyển tiếp tham chiếu: trả về T khi được cung cấp T&& và T& khi được cung cấp T&

  Xem xét một lớp A, làm cách nào tôi có thể viết một mẫu có hành vi tương tự như A& beautiful(A& x) { /* make x beautiful */ return x } A beautiful(A&& x) {

• java — Tại sao "t instanceof T" không được phép khi T là tham số loại và t là biến?

  Eclipse nói rằng thao tác instanceof không được phép trên các tham số kiểu do bộ xóa kiểu chung. Tôi đồng ý rằng sẽ không có thông tin loại nào được giữ lại trong thời gian chạy. Nhưng hãy xem xét khai báo chung sau đây của một lớp: class SomeClass{ T

• Sự khác biệt giữa T t {x} và T t = { x } đối với kiểu số nguyên hoặc kiểu liệt kê?

  Trong C++ 14: đối với mọi số nguyên hoặc kiểu liệt kê T và đối với mọi biểu thức expr: có sự khác biệt nào không: struct S { T t { expr } };