C+中的混淆+； 我对C++很陌生，我现在正在学习它。我有几个问题

voidDoSomething（const-Foo&Foo）和void-DoSomething（Foo-Foo）之间有什么区别？如果我们不指定，那么Foo的实例将按值传递（非引用）。除了在编译时不进行检查外，它与在参数中使用const+&in相同。那么，为什么使用const+&成为没有和const的争论的最佳实践呢

在C++中，传递对象是“引用”，但似乎不是C++中的。

我正在读的那本书说，成员函数通过引用传递隐式参数

有谁能给我一个隐式参数的例子，并通过引用？我知道，如果我们想通过引用传递对象，我们需要使用和（例如，FO（人和P）），但是C++如何通过引用传递参数来实现隐式参数？我读到C++中的隐式参数类似于StrutoCube（String STR）：STRAMSTATION变量（STR）{}…< / P>

< P>数组是C++中唯一通过引用的吗？

为什么我不能在Foo类中使用Foo fInstance

例如：

class Foo {

public:    
    Foo() { }

    Foo(const Foo& f) : fInstance(f) {   }  

    Foo fInstance;      
};

---

提前感谢。

无效剂量测量（const-Foo&Foo）和无效剂量测量（Foo-Foo）之间的差异是第一个通过引用传递参数，第二个通过值传递参数。实际的区别是：

效率。按值传递可能需要调用复制构造函数。如果复制构造函数很昂贵，则按值传递将增加更多开销

适用性。按值传递需要公共副本构造函数。如果类不支持复制构造函数，则不能按值传递它

语义学。通过引用传递时，您不知道对象可能被引用。如果由于其他原因更改了基础对象，则引用的值将更改

更好地解释α3，考虑这种情况：

std::string global_string;

void foo(const std::string &str)
{
    if (str.empty())
    {
        global_string = "whatever";
        // is str still empty??
    }
}

如果foo被称为

foo（global\u string）

，那么当您更改

global\u string

时，这也会更改

str

一次一个：

doStuff（Foo f）

表示在调用方法时，将在堆栈上创建一个新的

Foo

对象-AKA by value。调用

doStuff（constfoo&f）

意味着您只是传递了一个新的引用，对象没有重复，您只持有对它的引用。这是传递参数最安全的方法，因为它不涉及复制对象的副本。这称为通过引用传递，是最接近Java/C行为的

你说的是哪个隐式参数

同样，数组（假设它们是std：：arrays）可以通过值、指针或引用进行传递-没有单一行为。正如Konard提到的，C风格的数组（只不过是内存块）不能按值传递

实际上传递了一份foo的副本

void DoSomething(Foo& foo)

传递对foo的引用，因此如果在函数中修改foo，则将修改原始foo。我希望这是有道理的

对于数组，数组实际上是指向数组开头的指针，该指针被传递（不复制整个数组）

在C++中，传递对象是“引用”，但似乎不是C++中的。 不，这是错误的，这是一个常见的误解。在C#、VB和Java等语言中，变量总是按值传递（在C#中显式传递为

ref

，或在VB中显式传递为

ByRef

）

与C++不同的是，变量不包含类的对象本身，它们只包含引用。因此，传递给方法的不是对象本身，而是它的引用（而是通过值传递的引用）

差别是相当重要的。如果C#使用pass by reference，以下代码将打印不同的结果：

void foo(string s) {
    s = "world";
}

string s = "hello";
foo(s);
Console.WriteLine(s); // prints "hello"

void DoSomething（const Foo&Foo）和void DoSomething（Foo Foo）之间有什么区别

如果Foo是基本数据类型，DoSomething（Foo-Foo）通过值传递对象Foo；如果Foo是用户定义的数据类型，则通过引用传递对象Foo。但在第二种情况下，如果更改foo，它会反射回原始对象，这通常是不可取的。DoSomething（const Foo&Foo）通过引用传递Foo（从而节省了通过值传递的额外内存成本），并且仍然不向DoSomething函数提供Foo上的写访问权限。因此，这是一种最佳做法

有人能给我一份样品吗 隐式参数和引用

成员函数中隐式参数的一个示例是对父对象的引用，即

此

，函数定义中从未提及，但始终可用

数组是唯一经过的吗 C++中的引用？< /P>

---

否，所有用户定义的对象都是通过引用传递的

为什么我不能在Foo类中使用Foo fInstance

因为从概念上讲，Foo的对象需要无限的空间。从技术上讲，Foo类型在Foo的定义中是不完整的

您可能需要一个指向Foo作为成员的指针

我正在读的那本书说，成员函数通过引用传递隐式参数

这本书讨论的是传递给类中定义的每个非静态成员函数的隐式指针。这是因为C++在每个类中都不包含每个成员函数的副本，所以该方法应该知道它应该工作的类的对象。

class FOO{
 int x;
 void doSomthing(int x);
}

void FOO::doSomething(int x){
  x = x;
}

会被编译成这样的东西

void FOO::doSomething(FOO* this, int x){
  this->x = x;
}

由于静态函数是类函数而不是对象函数，它们不需要创建对象来调用，因此它们不应该访问类的非静态字段，因此不需要

class FOO{
 int x;
 void doSomthing(int x);
}

void FOO::doSomething(int x){
  x = x;
}

void FOO::doSomething(FOO* this, int x){
  this->x = x;
}

void fun(int* p, size_t size);

int main(int argc, char* argv[])
{
  int array[15];
  fun(array, 15);
}

void changer(int*& array, size_t& size);

class Foo
{
public:

private:
  std::unique_ptr<Foo> mInstance;
};

  What is the differences between void DoSomething(const Foo& foo) and

void foo(int[] x) { … }

void foo(int* x) { … }

void foo(int (&x)[4]);

class Foo
{
    Foo(int x) {...}
};

Foo foo = 123;

void f(const Foo& x);
f(123);

class Foo
{
    explicit Foo(int x) {...}
};

Foo foo(123);

void f(const Foo& x);
f(Foo(123) );

// takes an array of 10 integers
void fn(int(&some_array)[10]);

// takes a pointer to an int array
void fn(int* some_array);

// takes a pointer to an int array (the 10 
// literal constant is ignored) and this function
// can likewise take any pointer to int
void fn(int some_array[10]);