go python java_一文助你搞懂参数传递原理解析(java、go、python、c++)
前言
最近一年多的時(shí)間陸續(xù)接觸了一些對我來說陌生的語言，主要就是 Python 和 Go，期間為了快速實(shí)現(xiàn)需求只是依葫蘆畫瓢的擼代碼；并沒有深究一些細(xì)節(jié)與原理。
就拿參數(shù)傳遞一事來說各個(gè)語言的實(shí)現(xiàn)細(xì)節(jié)各不相同，但又有類似之處；在許多新手入門時(shí)容易搞不清楚，導(dǎo)致犯一些低級錯(cuò)誤。
Java
基本類型傳遞
先拿我最熟悉的 Java 來說，我相信應(yīng)該沒人會(huì)寫這樣的代碼：
@Test
public void testBasic() {
int a = 10;
modifyBasic(a);
System.out.println(String.format("最終結(jié)果 main a==%s", a));
}
private void modifyBasic(int aa) {
System.out.println(String.format("修改之前 aa==%s", aa));
aa = 20;
System.out.println(String.format("修改之后 aa==%s", aa));
}
輸出結(jié)果:
修改之前 aa==10
修改之后 aa==20
最終結(jié)果 main a==10
不過從這段代碼的目的來看應(yīng)該是想要修改 a 的值，從直覺上來說如果修改成功也是能理解的。
至于結(jié)果與預(yù)期不符合的根本原因是理解錯(cuò)了參數(shù)的值傳遞與引用傳遞。
在這之前還是先明確下值傳遞與引用傳遞的區(qū)別：
這里咱們先拋出結(jié)論，Java 采用的是值傳遞；這樣也能解釋為什么上文的例子沒有成功修改原始數(shù)據(jù)。
參考下圖更好理解：
當(dāng)發(fā)生函數(shù)調(diào)用的時(shí)候 a 將自己傳入到 modifyBasic 方法中，同時(shí)將自己的值復(fù)制了一份并賦值給了一個(gè)新變量 aa 從圖中可以看出這是 a 和 aa 兩個(gè)變量沒有一毛錢關(guān)系，所以對 aa 的修改并不會(huì)影響到 a。
有點(diǎn)類似于我把蘋果給了老婆，她把蘋果削好了；但我手里這顆并沒有變化，因?yàn)樗皇菑牟捅P里拿了一顆一模一樣的蘋果削好了。
如果我想要她那顆，只能讓她把削好的蘋果給我；也就類似于使用方法的返回值。
a = modifyBasic(a);
引用類型傳遞
下面來看看引用類型的傳遞：
private class Car{
private String name;
public Car(String name) {
this.name = name;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
'}';
}
}
@Test
public void test01(){
Car car1 = new Car("benz");
modifyCar1(car1);
System.out.println(String.format("最終結(jié)果 main car1==%s", car1));
}
private void modifyCar1(Car car){
System.out.println(String.format("修改之前 car==%s", car));
car.name = "bwm";
System.out.println(String.format("修改之后 car==%s", car));
}
在這個(gè)例子里先創(chuàng)建了一個(gè) benz 的 car1，通過一個(gè)方法修改為 bmw 那最開始的 car1 會(huì)受到影響嘛？
修改之前 car==Car{name='benz'}
修改之后 car==Car{name='bwm'}
最終結(jié)果 main car1==Car{name='bwm'}
結(jié)果可能會(huì)與部分人預(yù)期相反，這樣的修改卻是可以影響到原有數(shù)據(jù)的？這豈不是和值傳遞不符，看樣子這是引用傳遞吧？
別急，通過下圖分析后大家就能明白：
在 test01 方法中我們創(chuàng)建了一個(gè) car1 的對象，該對象存放于堆內(nèi)存中，假設(shè)內(nèi)存地址為 0x1102 ，于是 car1 這個(gè)變量便應(yīng)用了這塊內(nèi)存地址。
當(dāng)我們調(diào)用 modifyCar1 這個(gè)方法的時(shí)候會(huì)在該方法棧中創(chuàng)建一個(gè)變量 car ,接下來重點(diǎn)到了：
這個(gè) car 變量是由原本的入?yún)?car1 復(fù)制而來，所以它所對應(yīng)的堆內(nèi)存依然是 0x1102；
所以當(dāng)我們通過 car 這個(gè)變量修改了數(shù)據(jù)后，本質(zhì)上修改的是同一塊堆內(nèi)存中的數(shù)據(jù)。從而原本引用了這塊內(nèi)存地址的 car1 也能查看到對應(yīng)的變化。
這里理解起來可能會(huì)比較繞，但我們記住一點(diǎn)就行：
傳遞引用類型的數(shù)據(jù)時(shí)，傳遞的并不是引用本身，依然是值；只是這個(gè)值 是內(nèi)存地址罷了。
因?yàn)榘严嗤膬?nèi)存地址傳過去了，所以對數(shù)據(jù)的操作依然會(huì)影響到外部。
所以同理，類似于這樣的代碼也會(huì)影響到外部原始數(shù)據(jù)：
@Test
public void testList(){
List list = new ArrayList<>();
list.add(1);
addList(list);
System.out.println(list);
}
private void addList(List list) {
list.add(2);
}
[1, 2]
那如果是這樣的代碼：
@Test
public void test02(){
Car car1 = new Car("benz");
modifyCar(car1);
System.out.println(String.format("最終結(jié)果 main car1==%s", car1));
}
private void modifyCar(Car car2) {
System.out.println(String.format("修改之前 car2==%s", car2));
car2 = new Car("bmw");
System.out.println(String.format("修改之后 car2==%s", car2));
}
假設(shè) Java 是引用傳遞那最終的結(jié)果應(yīng)該是打印 bmw 才對。
修改之前 car2==Car{name='benz'}
修改之后 car2==Car{name='bmw'}
最終結(jié)果 main car1==Car{name='benz'}
從結(jié)果又能佐證這里依然是值傳遞。
如果是引用傳遞，原本的 0x1102 應(yīng)該是被直接替換為新創(chuàng)建的 0x1103 才對；而實(shí)際情況如上圖所示，car2 直接重新引用了一個(gè)對象，兩個(gè)對象之間互不干擾。
Go
相對于 Java 來說 Go 的用法又有所不同，不過我們也可以先得出結(jié)論：
Go語言的參數(shù)也是值傳遞。
在 Go 語言中數(shù)據(jù)類型主要有以下兩種：
值類型與引用類型；
值類型
先以值類型舉例：
func main() {
a :=10
modifyValue(a)
fmt.Printf("最終 a=%v", a)
}
func modifyValue(a int) {
a = 20
}
輸出：最終 a=10
函數(shù)調(diào)用過程與之前的 Java 類似，本質(zhì)上傳遞到函數(shù)中的值也是 a 的拷貝，所以對其的修改不會(huì)影響到原始數(shù)據(jù)。
當(dāng)我們把代碼稍加修改：
func main() {
a :=10
fmt.Printf("傳遞之前a的內(nèi)存地址%p \n", &a)
modifyValue(&a)
fmt.Printf("最終 a=%v", a)
}
func modifyValue(a *int) {
fmt.Printf("傳遞之后a的內(nèi)存地址%p \n", &a)
*a = 20
}
傳遞之前a的內(nèi)存地址0xc0000b4040
傳遞之后a的內(nèi)存地址0xc0000ae020
最終 a=20
從結(jié)果來看最終 a 的值是被方法修改了，這點(diǎn)便是 Go 與 Java 很大的不同點(diǎn)：
在 Go 中存在著指針的概念，我們可以將變量通過指針的方式傳遞到不同的方法中，在方法里便可通過這個(gè)指針訪問甚至修改原始數(shù)據(jù)。
那這么一看不就是引用傳遞嘛？
其實(shí)不然，我們仔細(xì)看看剛才的輸出會(huì)發(fā)現(xiàn)參數(shù)傳遞前后的內(nèi)存地址并不相同。
傳遞之前a的內(nèi)存地址0xc0000b4040
傳遞之后a的內(nèi)存地址0xc0000ae020
這也恰好論證了值傳遞，因?yàn)檫@里實(shí)際傳遞的是指針的拷貝。
也就是說 modifyValue 方法中的參數(shù)與入?yún)⒌?amp;a都是同一塊內(nèi)存的指針，但指針本身也是需要內(nèi)存來存放的，所以在方法調(diào)用過程中新建了一個(gè)指針 a ，從而導(dǎo)致他們的內(nèi)存地址不同。
雖然內(nèi)存地址不同，但指向的數(shù)據(jù)都是同一塊，所以方法內(nèi)修改后原始數(shù)據(jù)也受到了影響。
引用類型
對于 map slice channel 這類引用類型又略有不同：
func main() {
var personList = []string{"張三","李四"}
modifySlice(personList)
fmt.Printf("slice=%v \n", personList)
}
func modifySlice(personList []string) {
personList[1] = "王五"
}
slice=[張三 王五]
最終我們會(huì)發(fā)現(xiàn)原始數(shù)據(jù)也被修改了，但我們并沒有傳遞指針；同樣的特性也適用于 map 。
但其實(shí)我們查看 slice 的源碼會(huì)發(fā)現(xiàn)存放數(shù)據(jù)的 array 就是指針類型：
type slice struct {
array unsafe.Pointer
len int
cap int
}
所以我們可以直接對數(shù)據(jù)進(jìn)行修改，相當(dāng)于間接的帶了指針。
使用建議
那我們在什么時(shí)候使用指針呢？有以下幾點(diǎn)建議：
如果參數(shù)是基本的值類型，比如 int,float 建議直接傳值。如果需要修改基本的值類型，那只能是指針；但考慮到代碼可讀性還是建議將修改后的值返回用于重新賦值。數(shù)據(jù)量較大時(shí)建議使用指針，減少不必要的值拷貝。(具體多大可以自行判斷)
Python
在 Python 中變量是否可變是影響參數(shù)傳遞的重要因素：
如上圖所示，bool int float 這些不可變類型在參數(shù)傳遞過程中是不能修改原始數(shù)據(jù)的。
if __name__ == '__main__':
x = 1
modify(x)
print('最終 x={}'.format(x))
def modify(val):
val = 2
最終 x=1
原理與 Java Go中類似，是基于值傳遞的，這里就不再復(fù)述。
這里重點(diǎn)看看可變數(shù)據(jù)類型在參數(shù)傳遞中的過程：
if __name__ == '__main__':
x = [1]
modify(x)
print('最終 x={}'.format(x))
def modify(val):
val.append(2)
最終 x=[1, 2]
最終數(shù)據(jù)受到了影響，那么就表明這是引用傳遞嘛？再看個(gè)例子試試：
if __name__ == '__main__':
x = [1]
modify(x)
print('最終 x={}'.format(x))
def modify(val):
val = [1, 2, 3]
最終 x=[1]
顯而易見這并不是引用傳遞，如果是引用傳遞最終 x 應(yīng)當(dāng)?shù)扔?[1, 2 ,3] 。
從結(jié)果來看這個(gè)傳遞過程非常類似 Go 中的指針傳遞，val 拿到的也是 x 這個(gè)參數(shù)內(nèi)存地址的拷貝；他們都指向了同一塊內(nèi)存地址。
所以對這塊數(shù)據(jù)的修改本質(zhì)上改的是同一份數(shù)據(jù)，但一旦重新賦值就會(huì)創(chuàng)建一塊新的內(nèi)存從而不會(huì)影響到原始數(shù)據(jù)。
與 Java 中的上圖類似。
所以總結(jié)下：
對于不可變數(shù)據(jù)：在參數(shù)傳遞時(shí)傳遞的是值，對參數(shù)的修改不會(huì)影響到原有數(shù)據(jù)。
對于可變數(shù)據(jù)：傳遞的是內(nèi)存地址的拷貝，對參數(shù)的操作會(huì)影響到原始數(shù)據(jù)。
這么說來這三種都是值傳遞了，那有沒有引用傳遞的語言呢？
當(dāng)然，C++是支持引用傳遞的：
#include
using namespace std;
class Box
{
public:
double len;
};
void modify(Box& b);
int main ()
{
Box b1;
b1.len=100;
cout << "調(diào)用前，b1 的值：" << b1.len << endl;
modify(b1);
cout << "調(diào)用后，b1 的值：" << b1.len << endl;
return 0;
}
void modify(Box& b)
{
b.len=10.0;
Box b2;
b2.len = 999;
b = b2;
return;
}
調(diào)用前，b1 的值：100
調(diào)用后，b1 的值：999
可以看到把新對象 b2 賦值給入?yún)?b 后是會(huì)影響到原有數(shù)據(jù)的。
總結(jié)
其實(shí)這幾種語言看下來會(huì)發(fā)現(xiàn)他們中也有許多相似之處，所以通常我們在掌握一門語言后也能快速學(xué)習(xí)其他語言。
但往往是這些基礎(chǔ)中的基礎(chǔ)最讓人忽略，希望大家在日常編碼時(shí)能夠考慮到這些基礎(chǔ)知識多想想一定會(huì)寫出更漂亮的代碼(bug)。
到此這篇關(guān)于多種語言參數(shù)傳遞原理解析(java、go、python、c++)的文章就介紹到這了,更多相關(guān)java參數(shù)傳遞原理內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎(jiǎng)勵(lì)來咯，堅(jiān)持創(chuàng)作打卡瓜分現(xiàn)金大獎(jiǎng)總結(jié)
以上是生活随笔為你收集整理的go python java_一文助你搞懂参数传递原理解析(java、go、python、c++)的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 马斯克看了想打人 特斯拉前AI负责人宣布
- 下一篇： python台风动图绘制_使用Pytho