标签: pass-by-value

1. 为什么函数不x修改传递给它的列表的内容？
2. 我怎样才能改变MWE,这样x 不会改变传递给它的列表的内容？

>>> def x(mylist):
...     mylist = [ x for x in mylist if x > 5 ]
... 
>>> foo = [1,2,3,4,5,6,7,8,9,10]
>>> x(foo)
>>> print foo
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

该函数仅在 C 中的链表为空时才删除它。ll_length() 函数已确认有效。如果链表删除成功，则返回0。如果没有删除，则返回负1。该程序返回-1。它输入第一个 if 语句，但不输入第二个。怎么了

ll_destroy(struct linked_list *ll)
{
  if (ll_length(ll) == 0){
    free(ll);
    if (ll == NULL){
      return 0; //remove 0 if removed   
     }
  }
  return -1; // if not deleted
}

可能重复:
传递参考与传递值之间有什么区别？

我读到C语句中的参数是通过值传递的,但是按值传递参数(如在C中)或者通过refencence(如C++ - C#)之间的区别是什么？指针和引用之间有什么区别？

void with_ptr(int *i)
{ *i = 0; }

void with_ref(int &i)
{ i = 0; }

在这些情况下修改两个值？如果是,为什么C++允许通过引用传递参数？我认为在函数内部并不清楚i值是否可以修改.

似乎原子类型(int,string,...)是通过值传递的,而所有其他的(对象,指向函数的指针,指向方法的指针......)都是通过引用传递的.

检查变量是按值传递还是按引用传递的最佳方法是什么？

isinstance(input_, float) or isinstance(input_, basestring) or <...>

似乎非常不优雅.

我需要它的原因如下:我有一个包装wx.Button的类,如果args/kwargs是按值传递的类型,则不会考虑更新其他对象中的值.所以一些检查将是有益的

class PalpyButton(wx.Button):        
    def __init__(self, parent, btnLabel, handler, successMsg = None, args = (), kwargs = {}):
        super(PalpyButton, self).__init__(parent, -1, btnLabel)
        self.handler = handler
        self.successMsg = successMsg
        parent.Bind(wx.EVT_BUTTON, lambda event: self.onClick(event, *args, **kwargs), self)
    def onClick(self, event, *args, **kwargs):
        try:
            self.handler(*args, **kwargs)
            if self.successMsg != None:
                if hasattr(self.successMsg, '__call__'):
                    showInfoMessageBox(self.successMsg())
                else:
                    showInfoMessageBox(self.successMsg)
        except BaseException, detail:
            showErrorMessageBox(detail)

从有关const函数的MSDN页面

代码:

    // constant_member_function.cpp
class Date
{
public:
   Date( int mn, int dy, int yr );
   int getMonth() const;     // A read-only function
   void setMonth( int mn );   // A write function; can't be const
private:
   int month;
};

int Date::getMonth() const
{
   return month;        // Doesn't modify anything
}
void Date::setMonth( int mn )
{
   month = mn;          // Modifies data member
}
int main()
{
   Date MyDate( 7, 4, 1998 );
   const Date BirthDate( 1, 18, …

我来自java世界,我期待以下事情

int a = valueassignedbyfunction();
int b = a;
a = a + 1; 

在此之后a大于b.但是在python中,一旦a = a + 1操作完成,b就会自动增加1,因为这个b引用的是同一个对象.如何只复制a的值并将其分配给名为b的新对象？

谢谢!

考虑以下代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    class Foo
    {
        public int x { get; set; }
        public String y { get; set; }

        public Foo()
        {
            this.x = 1;
            this.y = "Jack";
        }
    }

    class Testing
    {
        public static void funcChange(Foo bar)
        {
            bar.x = 2;
            bar.y = "Inga";
        }

        public static void funcNull(Foo bar)
        {
            bar = null;
        }

        public static void Main()
        {
            Foo foo = new Foo();
            Foo foo2 …

在 JavaScript（或 TypeScript）中，对象是通过引用传递的，这与在函数中复制的原语不同。因此，是不是这样：

sum(one: number, two: number): number {
    return one + two;
}

总是比这效率低？

sum(input: { one: number, two: number}): number {
    return input.one + input.two;
}

在第一个函数中，'one' 和 'two' 被复制。在第二个函数中，'one' 和 'two' 只是对封装在对象中的原始 'one' 和 'two' 的引用，因此不会进行复制，这样可以节省计算量吗？

当然，如果我需要操纵 'one' 和 'two' 的值并且不希望更改持续存在，我会使用第二个函数。

因此，对于 JavaScript 开发人员来说，将他们的函数参数原语封装在一个对象中（假设他们不希望操作持续存在）不应该始终是建议的最佳实践吗？