Thread: Can't pass by reference?

Hello, I'm fairly new to Java, I'm very experienced with C++ and C# in which you can pass by reference - extremely useful. Take for example this bit of code in C#:

    class MyClass
    {
        public MyClass(int i)
        {
            m_i = i;
        }
 
        public int m_i;
    }
 
    class Program
    {
        static void DoSomething(ref int i)
        {
            i = i * 2;
        }
 
        static void Main(string[] args)
        {
            MyClass x = new MyClass(1);
            DoSomething(ref x.m_i);
            DoSomething(ref x.m_i);
            DoSomething(ref x.m_i);
        }
    }

Just at the end of this program x.m_i will be equal to 8. As far as I can see this is not possible in Java: you can't pass a double by reference, using a Double will kick in the autoboxing so that won't work either. The only "solution" in Java would be to pass in a double[] (of length 1) or to make a wrapper class, both nasty solutions because a user may want to just hold a double as a member of their class just as I have, for reasons such as not allocating more memory for a class and generally not being bloated. Does anybody have any ideas of a solution to this if there is one? if there isn't will there be one in Java?

Peter

Java does not pass parms by reference.

Please edit your post and wrap your code with code tags:
[code=java]
YOUR CODE GOES HERE
[/code]
to get highlighting and preserve formatting.

For your simple example, have doSomething() return the new value and have the caller assign it to i.

Java is pass-by-value. It is *not* pass-by-reference.

If that is confusing, please read this: JavaRanch Campfire - Cup Size: a Story About Variables
And then this: JavaRanch Campfire - Pass By Value, Please

The only way to accomplish what you want is by passing in a wrapper Object that contains a double.

I'm not sure how much overhead you think this is going to entail, but worrying about it seems like premature optimization to me.

Originally Posted by JavaDeveloperPeter

Thanks, but it is quite a nasty flaw

This is not a flaw. This is a purposeful design choice.

Originally Posted by JavaDeveloperPeter

Thanks, but it is quite a nasty flaw you can't seriously be saying that that is ok?

...I'm pretty fine with it.

If you want to program in C or C++, then program in C or C++. Not every language works the same.

If you say so. It's worked pretty fine for me up to this point.

What is your purpose for posting here? It sounds more like trolling than an attempt to learn java.

Originally Posted by JavaDeveloperPeter

Fair enough, but being told "not all languages are the same" maybe that isn't trolling but pretty daft, when I've raised a good question.

You claimed that a pretty basic design choice was a "serious flaw", hence the explanation that not all languages are the same, so just because something is *different* doesn't mean it's *wrong*.

I also don't really understand the motivations behind your posts. This is a technical forum, not a place to have pointless "language debates". Languages are tools. Different tools are better fit for different jobs. I've used C, C++, and C# in the past. Java is a better fit for most of the things I currently do. I'm not sure what you hope to achieve by telling me that "I don't know what I'm missing".

Given that java is pass by value, what is your question?

Originally Posted by JavaDeveloperPeter

I said that because I was irritated at the revelation that you gave me about languages being different

And I said that languages are different because you seemed confused that a *purposeful design choice* was somehow a *flaw* because it wasn't the same in some other language.

Originally Posted by JavaDeveloperPeter

And I was looking for a solution or if someone knows if there will be a solution to this.

You were given two separate approaches to this problem. What happened when you tried each?

Originally Posted by JavaDeveloperPeter

And I'm sure that anyone who is objective would agree with me __because__ a Double is a class __but__ the autoboxing ruins that fact in this context.

I'm not even sure what this sentence is supposed to mean. What exactly is "ruined"?

Originally Posted by JavaDeveloperPeter

I was looking for some clarification on this forum about a solution to what seems a contradiction even in the way the language is set up.

Like I said, you were given two solutions that you seem to be ignoring. And there is no contradiction: Java is *always* pass-by-value. No contradictions.

Note that your question has nothing to do with autoboxing, as the Double class is immutable anyway.

--- Update ---

Originally Posted by JavaDeveloperPeter

one should never question java developers about this.

You are more than welcome to ask specific technical questions here, as this is a technical forum and we're here answering questions, for fun, in our spare time. We just don't have time to feed the "Java sux, C++ is better" trolls who don't understand that languages are tools, not religions. We have plenty of other spam to get rid of, haha.

Originally Posted by JavaDeveloperPeter

For the record, my point about Double is what is the point of passing the class version of double if you can't set the value inside it.

This doesn't really have anything to do with autoboxing or pass-by-value or pass-by-reference. The primitive wrapper classes are simply **immutable**, just like many other classes. The String class is also immutable. So is the File class, the Color class, etc.

More info here: Immutable Objects (The Java™ Tutorials > Essential Classes > Concurrency)

Originally Posted by JavaDeveloperPeter

I won't post again here.

That's a bit extreme, but it's really up to you. Happy coding.

Give the problem you originally asked, I would have to ask what logical sense doing it the way you suggested in C# makes.
You passed the value 1 to an instance of the MyClass class, where you set the nonstatic variable m_i with the value 1. You then attempt to statically modify the value of m_i from outside of the MyClass instance? That just looks like a poor design.
Java encourages you to modify simply type fields of an instance of an object from within that object (you can do it externally by getting and setting, but that is generally poor design).
To do what you suggested in java:

class MyClass {
	public int m_i;
 
	public MyClass(int i) {
            m_i = i;
        } 
	public void doSomething() {
            m_i = m_i * 2;
        }
}
class Program {
        public static void Main(String[] args){
            MyClass x = new MyClass(1);
            x.doSomething();
            x.doSomething()
            x.doSomething()
	}
}

Given how basic that solution is (and how similar it is to your C# code), I'm not sure why you are so heated.

Hi aussiemcgr, just to clear it up, that is just an example, it would as you say be pointless. the problem is for example say you have an object containing many doubles and you want to solve or change them to solve some condition. typically you would use something like a newton raphson solver and in c++ pass in the variable addresses.

Hi jdv, please see my post to aussiemcgr. I think this is what gets people like me heated... "if you thiink a little". I admit to Norm and others that I was immature and too "religious". but comments like this are a little daft... clearly I am someone who thinks a lot, and clearly Java is great for some things, but to put it in your words and think a little you will see that there is something here that Java does miss over other languages, and to be correct I will say that of course Java has some great things that other languages don't have, for example it's GC is better than C#s and C++ doesn't even have one, unless you use the managed c++. I trolled a bit, but come on people, let's not be patronizing. And note that passing by reference for example how I showed in my example cannot result in any problems because pointers don't come in to it.

Originally Posted by JavaDeveloperPeter

let's not be patronizing.

You might want to adjust how easily you take offense to things. Jdv was not implying that you don't think enough, he was simply transitioning into a new paragraph. It almost seems like you *want* to get into an argument, with how easily offended you seem to be. The internet is a big scary place, and part of being a good programmer is knowing how to take criticism. If you can't read a single answer (which are being posted, for free, by volunteers doing this in their spare time) without taking offense to every other sentence, you might be better off paying for a tutor or a consultant instead.

Originally Posted by JavaDeveloperPeter

And note that passing by reference for example how I showed in my example cannot result in any problems.

Are you saying that passing by reference causes absolutely no problems? This is simply untrue, which is why Java chose to only use pass-by-value.

Passing by reference has its uses, but saying that it comes with absolutely no downsides is not true.

It looks like returning to a rather interesting /technical/ discussion in this context is not going to be possible, so I will provide a reference for future spelunkers regarding "how to simulate C++ references in Java": How can I simulate pass by reference in Java? - Stack Overflow

Every language has its own idioms, and there is a very good rationale for the Java spec to constrain how primitives (since they decided to have them) and objects are passed. This is discussed up-thread. But this does not mean, in this instance, that Java is missing the functionality that pass-by-ref can provide as it is often used in C++ (for example).

I'll restate the salient point here: Java passes object references (referred to as "pointers" in the spec), so anything you can do with a primitive reference in C++ you can do in Java.

It all depends on where you are coming from. Note that because of how objects are passed, Java coders don't have to worry about things like new() abuse, as is common in C++ (especially those of us who came to C++ from Java!)

tl;dr:

1. Java treats primitives and object parameters differently. The rationale for this includes (but is not limited to) increased type-safety, removing pointer math, and simplified class definition and method invocations.

2. There is nothing magical about C++ style pass-by-reference that cannot be achieved in Java with well-known idioms. (Other than those things that are explicitly disallowed, of course.)

Originally Posted by JavaDeveloperPeter

"if you thiink a little" ...

My intention was the third-person "you", without resorting to using the rather snobby sounding "one".

I did not intend for my neutral statement to be considered a dig. (This is why I did not quote you, but addressed my comment to the entire audience of the thread.)

On the contrary, I was calling out a subtlety in the language that is often missed by newcomers and experts alike.