266

我是 C++ 编程的新手，但我有 Java 方面的经验。我需要有关如何将对象传递给 C++ 中的函数的指导。

我是否需要传递指针、引用或非指针和非引用值？我记得在 Java 中没有这样的问题，因为我们只传递了持有对对象的引用的变量。

如果您还可以解释在哪里使用这些选项，那就太好了。

4

8 回答 8

294

C++11的经验法则：

按值传递，除非当

  1. 你不需要对象的所有权，一个简单的别名就可以了，在这种情况下你通过const引用传递，
  2. 你必须改变对象，在这种情况下，使用非const左值引用传递，
  3. 您将派生类的对象作为基类传递，在这种情况下，您需要通过引用传递。（使用前面的规则来确定是否通过const引用传递。）

几乎从不建议通过指针传递。可选参数最好表示为std::optional(boost::optional对于较旧的标准库)，并且通过引用可以很好地完成别名。

C++11 的移动语义使得按值传递和返回即使对于复杂对象也更具吸引力。

C++03的经验法则：

通过const引用传递参数，除非当

  1. 它们将在函数内部进行更改，并且此类更改应反映在外部，在这种情况下，您通过非const引用传递
  2. 该函数应该可以不带任何参数调用，在这种情况下您通过指针传递，以便用户可以传递NULL//代替0；nullptr应用前面的规则来确定是否应该通过指向const参数的指针传递
  3. 它们是内置类型，可以通过复制传递
  4. 它们将在函数内部进行更改，并且此类更改不应反映在外部，在这种情况下，您可以通过副本传递（另一种方法是根据前面的规则传递并在函数内部进行复制）

（这里，“按值传递”称为“按副本传递”，因为按值传递总是在 C++03 中创建副本）

还有更多，但是这几个初学者的规则会让你走得很远。

于 2010-01-26T12:15:06.330 回答
114

C++ 和 Java 中的调用约定存在一些差异。在 C++ 中，从技术上讲只有两种约定：按值传递和按引用传递，一些文献包括第三种按指针传递约定（实际上是指针类型的按值传递）。最重要的是，您可以将 const-ness 添加到参数的类型中，从而增强语义。

通过引用传递

通过引用传递意味着该函数将在概念上接收您的对象实例，而不是它的副本。引用在概念上是调用上下文中使用的对象的别名，不能为空。函数内部执行的所有操作都适用于函数外部的对象。此约定在 Java 或 C 中不可用。

按值传递（和按指针传递）

编译器将在调用上下文中生成对象的副本，并在函数内使用该副本。在函数内部执行的所有操作都是针对副本完成的，而不是外部元素。这是 Java 中原始类型的约定。

它的一个特殊版本是将指针（对象的地址）传递给函数。该函数接收指针，并且应用于指针本身的任何和所有操作都应用于副本（指针），另一方面，应用于取消引用指针的操作将应用于该内存位置的对象实例，因此该函数可能有副作用。使用指向对象的指针的按值传递的效果将允许内部函数修改外部值，与按引用传递一样，并且还允许可选值（传递空指针）。

这是 C 中函数需要修改外部变量时使用的约定，Java 中使用引用类型的约定：引用被复制，但引用的对象是相同的：对引用/指针的更改在外部不可见该功能，但指向内存的更改是。

将 const 添加到等式

在 C++ 中，您可以在不同级别定义变量、指针和引用时为对象分配常量。可以将变量声明为常量，可以声明对常量实例的引用，还可以定义所有指向常量对象的指针、指向可变对象的常量指针和指向常量元素的常量指针。相反，在 Java 中，您只能定义一个级别的常量（final 关键字）：变量的级别（原始类型的实例，引用类型的引用），但您不能定义对不可变元素的引用（除非类本身是不变）。

这在 C++ 调用约定中广泛使用。当对象很小时，您可以按值传递对象。编译器将生成一个副本，但该副本不是昂贵的操作。对于任何其他类型，如果函数不会改变对象，则可以将引用传递给该类型的常量实例（通常称为常量引用）。这不会复制对象，而是将其传递给函数。但同时编译器会保证对象在函数内部没有改变。

经验法则

这是一些需要遵循的基本规则：

  • 首选原始类型的按值传递
  • 更喜欢通过引用传递其他类型的常量引用
  • 如果函数需要修改参数，请使用 pass-by-reference
  • 如果参数是可选的，则使用传递指针（如果不应该修改可选值，则传递给常量）

这些规则还有其他一些小的偏差，首先是处理对象的所有权。当一个对象用 new 动态分配时，它必须用 delete （或其 [] 版本）释放。负责销毁对象的对象或函数被认为是资源的所有者。当在一段代码中创建动态分配的对象，但所有权转移到不同的元素时，通常使用传递指针语义，或者如果可能的话使用智能指针。

边注

坚持 C++ 和 Java 引用之间差异的重要性很重要。在 C++ 中，引用在概念上是对象的实例，而不是它的访问器。最简单的例子是实现一个交换函数：

// C++
class Type; // defined somewhere before, with the appropriate operations
void swap( Type & a, Type & b ) {
   Type tmp = a;
   a = b;
   b = tmp;
}
int main() {
   Type a, b;
   Type old_a = a, old_b = b;
   swap( a, b );
   assert( a == old_b );
   assert( b == old_a ); 
}

上面的交换函数通过使用引用来改变它的两个参数。Java中最接近的代码：

public class C {
   // ...
   public static void swap( C a, C b ) {
      C tmp = a;
      a = b;
      b = tmp;
   }
   public static void main( String args[] ) {
      C a = new C();
      C b = new C();
      C old_a = a;
      C old_b = b;
      swap( a, b ); 
      // a and b remain unchanged a==old_a, and b==old_b
   }
}

Java 版本的代码将在内部修改引用的副本，但不会在外部修改实际对象。Java 引用是没有指针运算的 C 指针，它按值传递给函数。

于 2010-01-26T13:17:58.900 回答
24

有几种情况需要考虑。

参数修改（“out”和“in/out”参数）

void modifies(T &param);
// vs
void modifies(T *param);

这个案例主要是关于风格：你想让代码看起来像call(obj)还是call(&obj)？但是，有两点区别很重要：下面的可选情况，以及您希望在重载运算符时使用引用。

...和可选的

void modifies(T *param=0);  // default value optional, too
// vs
void modifies();
void modifies(T &param);

参数未修改

void uses(T const &param);
// vs
void uses(T param);

这是一个有趣的案例。经验法则是“廉价复制”类型是按值传递的——这些通常是小类型（但并非总是如此）——而其他类型是通过 const ref 传递的。但是，如果您无论如何都需要在函数中进行复制，则应按值传递。（是的，这暴露了一些实现细节。C'est le C++。）

...和可选的

void uses(T const *param=0);  // default value optional, too
// vs
void uses();
void uses(T const &param);  // or optional(T param)

所有情况之间的差异最小，所以选择让你的生活更轻松的那个。

const by value 是一个实现细节

void f(T);
void f(T const);

这些声明实际上是完全相同的功能！ 按值传递时， const 纯粹是一个实现细节。 试试看：

void f(int);
void f(int const) { /* implements above function, not an overload */ }

typedef void NC(int);       // typedefing function types
typedef void C(int const);

NC *nc = &f;  // nc is a function pointer
C *c = nc;    // C and NC are identical types
于 2010-10-19T15:00:46.147 回答
22

按值传递：

void func (vector v)

当函数需要与环境完全隔离时，按值传递变量，即防止函数修改原始变量以及防止其他线程在函数执行时修改其值。

缺点是复制对象所花费的 CPU 周期和额外内存。

通过 const 引用传递：

void func (const vector& v);

这种形式模拟了按值传递的行为，同时消除了复制开销。该函数获得对原始对象的读取权限，但不能修改其值。

缺点是线程安全：另一个线程对原始对象所做的任何更改都会在函数仍在执行时显示在函数内部。

通过非常量引用传递：

void func (vector& v)

当函数必须将一些值写回变量时使用它，最终将被调用者使用。

就像 const 参考案例一样，这不是线程安全的。

通过 const 指针传递：

void func (const vector* vp);

除了语法不同外，功能上与通过 const-reference 传递相同，而且调用函数可以传递 NULL 指针以指示它没有要传递的有效数据。

不是线程安全的。

通过非常量指针传递：

void func (vector* vp);

类似于非常量引用。当函数不应该写回一个值时，调用者通常将变量设置为 NULL。在许多 glibc API 中都可以看到这种约定。例子：

void func (string* str, /* ... */) {
    if (str != NULL) {
        *str = some_value; // assign to *str only if it's non-null
    }
}

就像所有通过引用/指针传递一样，不是线程安全的。

于 2014-11-06T14:26:51.337 回答
0

由于没有人提到我正在添加它，当您将对象传递给 c++ 中的函数时，如果您没有创建对象克隆然后将其传递给方法的对象的默认复制构造函数，则会调用该对象的默认复制构造函数，所以当您更改将反映在对象副本而不是原始对象上的对象值时，这就是c ++中的问题，因此，如果您将所有类属性都设为指针，那么复制构造函数将复制对象的地址指针属性，因此当对对象调用操作存储在指针属性地址中的值的方法时，更改也会反映在作为参数传递的原始对象中，因此它的行为与 Java 相同，但不要忘记您的所有类属性必须是指针，你也应该改变指针的值，代码解释会很清楚。

Class CPlusPlusJavaFunctionality {
    public:
       CPlusPlusJavaFunctionality(){
         attribute = new int;
         *attribute = value;
       }

       void setValue(int value){
           *attribute = value;
       }

       void getValue(){
          return *attribute;
       }

       ~ CPlusPlusJavaFuncitonality(){
          delete(attribute);
       }

    private:
       int *attribute;
}

void changeObjectAttribute(CPlusPlusJavaFunctionality obj, int value){
   int* prt = obj.attribute;
   *ptr = value;
}

int main(){

   CPlusPlusJavaFunctionality obj;

   obj.setValue(10);

   cout<< obj.getValue();  //output: 10

   changeObjectAttribute(obj, 15);

   cout<< obj.getValue();  //output: 15
}

但这不是一个好主意，因为您最终将编写大量涉及指针的代码，这些代码容易发生内存泄漏并且不要忘记调用析构函数。并且为了避免这种 c++ 具有复制构造函数，当包含指针的对象传递给将停止操作其他对象数据的函数参数时，您将在其中创建新内存，Java 确实按值传递并且值是引用，因此它不需要复制构造函数。

于 2015-02-04T06:03:33.837 回答
0

我是否需要传递指针、引用或非指针和非引用值？

这是一个在编写函数和选择参数类型时很重要的问题。该选择将影响函数的调用方式，并且取决于几件事。

最简单的选择是按值传递对象。这基本上在函数中创建了对象的副本，这有很多优点。但有时复制成本很高，在这种情况下，经常引用 ,const&通常是最好的。有时你需要你的对象被函数改变。然后需要一个非常量引用 , &。

有关参数类型选择的指导，请参阅C++ Core Guidelines 的 Functions 部分，从F.15开始。作为一般规则，尽量避免使用原始指针，*.

于 2021-01-27T12:27:08.967 回答
-1

将对象作为参数传递给函数的三种方法：

  1. 通过引用传递
  2. 按值传递
  3. 在参数中添加常数

通过以下示例：

class Sample
{
public:
    int *ptr;
    int mVar;

    Sample(int i)
    {
        mVar = 4;
        ptr = new int(i);
    }

    ~Sample()
    {
        delete ptr;
    }

    void PrintVal()
    {
        cout << "The value of the pointer is " << *ptr << endl
             << "The value of the variable is " << mVar;
   }
};

void SomeFunc(Sample x)
{
cout << "Say i am in someFunc " << endl;
}


int main()
{

  Sample s1= 10;
  SomeFunc(s1);
  s1.PrintVal();
  char ch;
  cin >> ch;
}

输出：

说我在 someFunc
指针的值为 -17891602
变量的值为 4

于 2011-03-09T17:24:30.060 回答
-2

以下是将参数/参数传递给 C++ 函数的方法。

1. 按价值。

// passing parameters by value . . .

void foo(int x) 
{
    x = 6;  
}

2. 参考。

// passing parameters by reference . . .

void foo(const int &x) // x is a const reference
{
    x = 6;  
}

// passing parameters by const reference . . .

void foo(const int &x) // x is a const reference
{
    x = 6;  // compile error: a const reference cannot have its value changed!
}

3. 按对象。

class abc
{
    display()
    {
        cout<<"Class abc";
    }
}


// pass object by value
void show(abc S)
{
    cout<<S.display();
}

// pass object by reference
void show(abc& S)
{
    cout<<S.display();
}
于 2015-12-04T06:12:29.980 回答