标签: call-by-value

public class StackOverFlow {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("A");
        al.add("B");
        markAsNull(al);
        System.out.println("ArrayList elements are "+al);

        String str = "Hello";
        markStringAsNull(str);
        System.out.println("str "+ str);
    }
    private static void markAsNull(ArrayList<String> str){
        str.add("C");
        str= null;
    }
    private static void markStringAsNull(String str){
        str = str + "Append me";
        str = null;
    }
}

这输出:

ArrayList elements are [A, B, C]
str Hello

在这种情况下ArrayList,添加的元素将被检索.如果String方法调用对传递的String没有影响.JVM到底在做什么？谁能详细解释一下？

我想知道什么是需要的电话.

虽然我在维基百科搜索并在此处找到它:http://en.wikipedia.org/wiki/Evaluation_strategy,但无法正确理解.如果有人可以用一个例子来解释并指出与按值调用的差异,那将是一个很大的帮助.

关于对象(尤其是字符串),通过引用调用比按值调用更快,因为函数调用不需要创建原始对象的副本.使用const,还可以确保不滥用引用.

我的问题是,如果使用原始类型(如bool,int或double),const call-by-reference是否也更快.

void doSomething(const string & strInput, unsigned int iMode);
void doSomething(const string & strInput, const unsigned int & iMode);

我怀疑,一旦原始类型的字节大小超过地址值的大小,使用call-by-reference是有利的.即使差异很小,我也想利用它,因为我经常调用其​​中的一些功能.

附加问题:内联是否会对我的问题的答案产生影响？

我有以下两个功能:

Class foo(Class arg)
{
    return arg;
}

Class bar(Class *arg)
{
    return *arg;
}

现在,当我单独调用foo(arg)时,复制构造函数当然会被调用两次.当我单独调用bar(&arg)时,它只调用一次.因此,我期待

foo(bar(&arg));

复制构造函数在这里被调用三次.但是,它仍然只被调用两次.这是为什么？编译器是否识别出不需要另一个副本？

提前致谢!

def getStr(): String = {
  println("getStr is running")
  "str"
}

def lazyHello(para: => String) = {
  println("lazy hello is runing")
  println(para)
}

def notLazyHello(para: String) = {
  println("not lazy hello is runing")
  println(para)
}

def anoyHello(para: () => String) = {
  println("anoy hello is runing")
  println(para())
}

notLazyHello(getStr)
lazyHello(getStr)
anoyHello(getStr)

得到了这个结果:

scala> notLazyHello(getStr)
getStr is running
not lazy hello is runing
str

scala>     lazyHello(getStr)
lazy hello is runing
getStr is running
str

scala>     anoyHello(getStr)
anoy hello is runing
getStr is …

问题很简单,之前可能已经讨论过,但我可以为我的案例找到一个明确的答案.假设我将指针对象传递给函数

#include "foo.h"
int main()
{
   foo * aFoo = new foo;
   bar(aFoo);
   delete aFoo;
   aFoo = NULL;
   return 0;
}

然后函数就像这样写

void bar (foo *f)
{
  f->insert();
}

问题:

那是一个call by value还是call by reference？我知道在按值调用时,将对象从main()复制到bar()会产生开销.所以我想确定这是一个call by reference.

我知道 C 和 C++ 中按引用传递的整个概念，以及 Java 中仅按值传递的类似概念。但从某种角度来看，一切都是按价值传递的，不是吗？在 C 中，我们将变量的指针传递给函数。所以我们只是将 的引用值传递给函数。这就是我们说 Java 不支持引用传递的原因，因为我们只是将引用变量的值传递给函数。所以我们按值传递引用。尽管在 C++ 中，有一种通过引用传递的方法，因为我们可以传递参数，并且该函数将使用这种格式使用相同的内存位置

void swap(int &x, int &y)

但在 C 中通过指针按引用传递只是按值传递指针。

void swap(int* x, int* y)

我知道这个问题可能看起来有点愚蠢，但我觉得我的整个概念有一个很大的漏洞。那么按引用调用的实际定义是什么，这只是另一个上下文中按值调用的伪名称吗？

在另一个问题中,Bob 为无类型lambda演算提供了以下解释器.

data Expr = Var String | Lam String Expr | App Expr Expr

data Value a = V a | F (Value a -> Value a)

interpret :: [(String, Value a)] -> Expr -> Value a
interpret env (Var x) = case lookup x env of
  Nothing -> error "undefined variable"
  Just v -> v
interpret env (Lam x e) = F (\v -> interpret ((x, v):env) e)
interpret env (App e1 e2) = case …

我正在读一本由 Brian W. Kernighan 和 Dennis M. Ritchie 撰写的《c 编程语言》一书。

本书列出了下面的代码

void strcpy(char *s, char *t){
    while((*s = *t) != '\0'){
        s++;
        t++;
    }
}

并说：

因为参数是按值传递的，所以 strcpy 可以以任何它喜欢的方式使用参数 s和t

我不同意这一点。为什么上面的参数是按值传递的？

根据另一本书《C 如何编程》：

在 C 中，您使用指针和间接运算符来模拟引用调用。当调用带有应修改参数的函数时，将传递参数的地址。

从后一个角度来看，它绝对是按引用调用。

请告诉我哪种方法是正确的以及为什么，谢谢！

顺便说一句，赋值后*s = *t，与哪一个进行比较'\0'？*s或者*t？

所以我的疑问是，我正在尝试按值调用，在运行给定代码时，在int main（）之后编写函数定义时发生交换，但是如果我在int main（）之上剪切并粘贴函数定义，则交换确实没有发生。这是为什么？

#include<iostream>
#include<string>
#include<vector>
#include<bitset>
#include<fstream>
using namespace std;
#define ADDU 1
#define SUBU 3
#define AND 4
#define OR  5
#define NOR 7
#define MemSize 65536
void swap(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
}

int main(){
    // int a = 20;
    // int *p = &a;
    // cout<<"P: "<<p<<endl<<"*P gives: "<<*p<<endl<<"&p gives: "<<&p<<endl<<"&a : "<<&a;;

    int x,y;
    x = 10;
    y = 20;
    cout<<"Before Swapping: "<<"x: "<<x<<endl<<"y: "<<y<<endl; …