C++ [C+；+；传递值]：被调用函数能否修改原始变量的内容？

我一直假设在[c++]中用[pass by value]传递变量会生成它们的副本，因此接收这些副本的函数不能更改原始变量的内容

我猜这是因为当参数按值传递时，调用了[copy constructor]，如果程序员没有重写它，默认的[copy constructor]会执行[shallow copy]而不是[deep copy]

所以我的问题是，为什么他们称它为按值传递，而在类中有指针的情况下，函数可以访问该指针的引用，并且可能会损坏它。这个结论是否正确？只要类中有指针，并且可以通过值作为函数参数传递该类的对象，请定义复制构造函数

如果这个错误很有名，有人知道这个问题的名称或短语吗

下面是导致修改列表的代码。此类的对象包含一个int成员变量 以及指向节点列表成员变量的指针

class ComplicatedObject{  
  public:
    ComplicatedObject();
    ~ComplicatedObject();

    //ComplicatedObject(const ComplicatedObject& c);  // copy construtor
    //ComplicatedObject& operator=(const ComplicatedObject& c); // =operator

    int int_member_varialbe_;  // an int member variable
    void addToList(int d);
    void printList();

  private:
    struct node{
      int data;
      node* next;
    };
    node* head_;  // points to the beginning of a list (linkedlist of int)
};

下面的代码打印2。然后打印出23张

Test.cpp:

void myfunction(ComplicatedObject obj){
  obj.addToList(3);
  obj.int_member_variable_ = 5;
}

int main(void){
  ComplicatedObject c_object;
  c_object.addToList(2);
  c_object.printList();  //prints 2 

  cout << "int member variable befor passing:";
  cout << c-object.int_member_variable_ << endl;  //prints 6 (a default value)

  myfunction(c_object); //pass-by-value

  cout << "int member variable after passing:";
  cout << c-object.int_member_variable_ << endl;  // prints 6 (not 5)

  c_object.printList(); // prints 2 3 ! List get changed!

  return 0;
}

Test.cpp：
void myfunction（复杂对象obj）{
对象添加列表（3）；
obj.int成员变量=5；
}
内部主（空）{
复杂对象c_对象；
c_object.addToList（2）；
c_object.printList（）；//打印2
cout您是正确的。浅层复制（如果您的类缺少复制构造函数，则会发生）复制类中的指针，但不复制它们指向的对象。如果您希望能够正确地按值传递非常量对象，则必须定义一个执行深度复制的复制构造函数。
您是正确的。浅层复制（如果您的类缺少复制构造函数，则会发生这种情况）复制类中的指针，但不复制它们指向的对象。如果希望能够正确地按值传递非常量对象，则必须定义执行深度复制的复制构造函数

所以我的问题是，为什么他们称它为按值传递，而在类中有指针的情况下，函数可以访问该指针的引用，并且可能会损坏它

我们考虑以下情况：

int func(int b, int* c)
{
  /* some stuff */
}

对于第一个参数，
b
，它是一个“ByVal”传递，因此编译器通常做的是

为
b创建
sizeof（int）
空间

将
b
复制到空白处
func
可以修改
b
的本地副本，而不影响原始
b
这是必要的，因为如果它是“ByRef”自动传递的，当给出非L值（即1）时，编译器将遇到问题，因为您无法从常量值获取引用

现在让我们看看
c
的情况。同样，它的类型是
int*
，而不是
int&
，因此它的处理方式与
intb
相同

但是，当
c
是
int*
指针时，它不存储任何其他数据，除了指向类型为
int的某个对象的地址。因此，允许通过指针进行间接访问，并且只有地址的副本，而没有它指向的值，因此可能会被损坏

所以我的问题是，为什么他们称它为按值传递，而在类中有指针的情况下，函数可以访问该指针的引用，并且可能会损坏它

我们考虑以下情况：

int func(int b, int* c)
{
  /* some stuff */
}

对于第一个参数，
b
，它是一个“ByVal”传递，因此编译器通常做的是

为
b创建
sizeof（int）
空间

将
b
复制到空白处
func
可以修改
b
的本地副本，而不影响原始
b
这是必要的，因为如果它是“ByRef”自动传递的，当给出非L值（即1）时，编译器将遇到问题，因为您无法从常量值获取引用

现在让我们看看
c
的情况。同样，它的类型是
int*
，而不是
int&
，因此它的处理方式与
intb
相同

但是，当
c
是
int*
指针时，它不存储任何其他数据，除了指向类型为
int的某个对象的地址。因此，允许通过指针进行间接访问，并且只有地址的副本，而没有它指向的值，因此可能会被损坏

我一直假设在
[c++]，制作它们的副本，因此函数接收这些
副本不能更改原始变量的内容

是的，没错

我猜这是因为当参数通过值传递时，
调用[copy constructor]，如果它未被
程序员，默认的[copy constructor]改为[shallow copy]
[深度复制]

“复制”是“浅层复制”。复制对象的所有内容。内容是字段。如果字段是指针，那么内容就是指针，地址。就是这样

所以我的问题是，为什么他们在
在类中有指针的情况下，函数可以访问
该指针的引用，可能会损坏它

那么？那些指针指向的东西不是对象的一部分。所以它是不相关的。指针是对象的一部分

我一直假设在
[c++]，制作它们的副本，因此函数接收这些
副本不能更改原始变量的内容

是的，没错

我猜这是因为当参数通过值传递时，
调用[copy constructor]，如果它未被
程序员，默认的[copy constructor]改为[shallow copy]
[深度复制]

“复制品”是“肤浅的公司”