関数パラメータの参照渡しとはどういうことなのか？ #JavaScript

関数パラメータの参照渡しとはどういうことなのか？

関数呼び出しで、関数(メソッド)のパラメータの渡し方には「値渡し」と「参照渡し」というのがあります。

ただ、Java や JavaScript には言語仕様としての参照渡しはなく、常に値渡しになります。

参照渡しの例ですが、最初に C# を例にして説明します。次のサンプルは２つのパラメータの値を交換するのに参照渡しを使っています。

using System;

public class SwapFunc
{
  static void Main(String[] args)
  {
    int x = 0;
    int y = 1;

    // x と y の値を交換
    Swap(ref x, ref y);

    Console.WriteLine("x = {0:d}, y = {1:d}\n", x, y);
  }

  // x と y の値を交換するメソッド
  static void Swap(ref int x, ref int y)
  {
    var u = x;
    x = y;
    y = u;
  }
}

これの IL (中間コード) は次のようになります。

コメントに動作を書きましたが、正確かどうかは別として、スタックマシン (仮想マシン) を使って、スタックフレーム上のデータをプッシュしたりポップしたりして計算を行っています。

このまま実行すると遅いので、通常、さらにネイティブコードに変換されて実行されます。

参照渡しに関わる部分は Main では、IL_0005 と IL_0006 のあたりです。ここで、スタックフレーム上のデータ x, y のアドレスをスタックに積んでいます。

関数 Swap 側で参照渡しに関わる部分は、ldind 命令を使っているあたりです。この命令は指定したオペランドの内容をアドレスとみなして、そのアドレスの行った先のデータをスタックに積んでいます。

//  Microsoft (R) .NET Framework IL Disassembler.  Version 4.0.30319.18020
//  Copyright (c) Microsoft Corporation. All rights reserved.



// Metadata version: v4.0.30319
.assembly extern mscorlib
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
  .ver 4:0:0:0
}
.assembly Swap
{
  .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) 
  .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78   // ....T..WrapNonEx
                                                                                                             63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 )       // ceptionThrows.
  .hash algorithm 0x00008004
  .ver 0:0:0:0
}
.module Swap.exe
// MVID: {DDFC4E86-9AF5-4AC3-927E-267DAB2AEE1E}
.imagebase 0x00400000
.file alignment 0x00000200
.stackreserve 0x00100000
.subsystem 0x0003       // WINDOWS_CUI
.corflags 0x00000001    //  ILONLY
// Image base: 0x04700000


// =============== CLASS MEMBERS DECLARATION ===================

.class public auto ansi beforefieldinit SwapFunc
       extends [mscorlib]System.Object
{
  .method private hidebysig static void  Main(string[] args) cil managed
  {
    .entrypoint
    // コード サイズ       39 (0x27)
    .maxstack  3
    .locals init (int32 V_0,
             int32 V_1)
    IL_0000:  nop
    IL_0001:  ldc.i4.0　　' 0 をプッシュ。
    IL_0002:  stloc.0　　' 0 をポップしスタックフレーム V_0 に保存
    IL_0003:  ldc.i4.1　　' 1 をプッシュ。
    IL_0004:  stloc.1　　' 1 をポップしてスタックフレーム V_1 に保存
    IL_0005:  ldloca.s   ' V_0　　V_0 のアドレスをプッシュ。
    IL_0007:  ldloca.s   ' V_1　　V_1 のアドレスをプッシュ。
    IL_0009:  call       void SwapFunc::Swap(int32&,　　' Swap をコール
                                             int32&)
    IL_000e:  nop　　　何もしない。
    IL_000f:  ldstr      "x = {0:d}, y = {1:d}\n"　　' フォーマットのアドレスをプッシュ
    IL_0014:  ldloc.0　　' V_0 の値をプッシュ。
    IL_0015:  box        [mscorlib]System.Int32　' スタックのトップをボクシング
    IL_001a:  ldloc.1　　' V_1 の値をプッシュ。
    IL_001b:  box        [mscorlib]System.Int32　' スタックのトップをボクシング
    IL_0020:  call       void [mscorlib]System.Console::WriteLine(string,　' Console.WriteLine をコール
                                                                  object,
                                                                  object)
    IL_0025:  nop  ' 何もしない。
    IL_0026:  ret　　' もどる。
  } // end of method SwapFunc::Main

  .method private hidebysig static void  Swap(int32& x,
                                              int32& y) cil managed
  {
    // コード サイズ       12 (0xc)
    .maxstack  2
    .locals init (int32 V_0)
    IL_0000:  nop
    IL_0001:  ldarg.0　　' 引数0をプッシュ。
    IL_0002:  ldind.i4　 ' スタックトップをアドレスとしてその行った先の内容をプッシュ。
    IL_0003:  stloc.0　　' ローカル変数 0 に格納。
    IL_0004:  ldarg.0 　' 引数0をプッシュ。
    IL_0005:  ldarg.1　 ' 引数1をプッシュ。
    IL_0006:  ldind.i4  ' スタックトップをアドレスとして、その行った先の内容をプッシュ。
    IL_0007:  stind.i4  ' スタックトップをアドレスとして、その行った先へストア。
    IL_0008:  ldarg.1　' 引数1をプッシュ。
    IL_0009:  ldloc.0　' ローカル変数0をプッシュ。
    IL_000a:  stind.i4　' その行った先の内容をプッシュ。
    IL_000b:  ret
  } // end of method SwapFunc::Swap

  .method public hidebysig specialname rtspecialname 
          instance void  .ctor() cil managed
  {
    // コード サイズ       7 (0x7)
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
    IL_0006:  ret
  } // end of method SwapFunc::.ctor

} // end of class SwapFunc


// =============================================================

// *********** 逆アセンブルが完了しました ***********************
// 警告: Win32 リソース ファイル C:\workspace\dotNET\IL\Swap\Swap.res を作成しました。

次に、C 言語の例を見てみます。

C 言語の場合、VM (仮想マシン) は使用しない、つまり、いきなりネイティブコードを生成します。

ここでは、PC で使われている x86 と x64 について述べます。RISC や IBM などでは、基本的考え方は同じはずですが、Calling Convention (呼び出し規約) がそれぞれ異なるのでいろいろ異なります。

まず、C のソースですが、下のようなものとします。

#include <stdio.h>

void swap(int*, int*);

int main(int argc, char* argv[]) {
  int x = 0;
  int y = 1;

  swap(&x, &y);

  printf("x = %d, y = %d\n", x, y);

  return 0;
}

void swap(int* x, int* y) {
  int u = *x;
  *x = *y;
  *y = u;
}

これのコンパイル結果は、次のようになります。(x86 の場合)

    .file   "Swap.c"
    .section    .rodata
.LC0:
    .string "x = %d, y = %d\n"
    .text
.globl main
    .type   main, @function
main:
    leal    4(%esp), %ecx
    andl    $-16, %esp
    pushl   -4(%ecx)
    pushl   %ebp
    movl    %esp, %ebp
    pushl   %ecx
    subl    $36, %esp
    movl    $0, -8(%ebp) # 0 をスタックフレームのローカルアドレスに保存(x)
    movl    $1, -12(%ebp) # 1 をスタックフレームのローカルアドレスに保存(y)
    leal    -12(%ebp), %eax # y のアドレスを EAX にロード
    movl    %eax, 4(%esp) # EAX をスタックに積む。
    leal    -8(%ebp), %eax # x のアドレスを EAX にロード
    movl    %eax, (%esp) # EAX をスタックに積む。
    call    swap # 関数 swap を呼び出す。
    movl    -12(%ebp), %eax
    movl    -8(%ebp), %edx
    movl    %eax, 8(%esp)
    movl    %edx, 4(%esp)
    movl    $.LC0, (%esp)
    call    printf
    movl    $0, %eax
    addl    $36, %esp
    popl    %ecx
    popl    %ebp
    leal    -4(%ecx), %esp
    ret
    .size   main, .-main
.globl swap
    .type   swap, @function
swap:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $16, %esp
    movl    8(%ebp), %eax # 後から積んだパラメータ(x)を EAX にロード
    movl    (%eax), %eax # EAX の行った先のデータを EAX にロード
    movl    %eax, -4(%ebp) # EAX をローカル変数に保存。
    movl    12(%ebp), %eax # 最初に積んだパラメータ(y)を EAX にロード
    movl    (%eax), %edx # EAX の行った先のデータを EDX にロード
    movl    8(%ebp), %eax # 後から積んだパラメータ(x)を EAX にロード
    movl    %edx, (%eax) # EDX を EAX の行った先に保存
    movl    12(%ebp), %edx # 最初に積んだパラメータ(y)を EDX にロード
    movl    -4(%ebp), %eax # ローカル変数の内容を EAX にロード
    movl    %eax, (%edx) # EAX を EDX の行った先に保存。
    leave
    ret
    .size   swap, .-swap
    .ident  "GCC: (GNU) 4.1.2 20080704 (Red Hat 4.1.2-54)"
    .section    .note.GNU-stack,"",@progbits

x64 の場合は、関数の呼び出し規約が異なっており、整数や浮動小数点数は最適化しなくてもレジスタ渡しになります。

これは、x64 では、汎用レジスタが8本から16本に増えたためで、余ったレジスタを関数のパラメータとして活用しています。

    .file   "Swap.c"
    .section    .rodata
.LC0:
    .string "x = %d, y = %d\n"
    .text
    .globl  main
    .type   main, @function
main:
.LFB0:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    subq    $32, %rsp
    movl    %edi, -20(%rbp)
    movq    %rsi, -32(%rbp)
    movl    $0, -8(%rbp)
    movl    $1, -4(%rbp)
    leaq    -4(%rbp), %rdx # RDX には y のアドレスが入る。
    leaq    -8(%rbp), %rax # RAX には x のアドレスが入る。
    movq    %rdx, %rsi # 呼び出し規約に基づいて、パラメータを RSI レジスタ渡しにしている。
    movq    %rax, %rdi # 呼び出し規約に基づいて、パラメータを RDI レジスタ渡しにしている。
    call    swap
    movl    -4(%rbp), %edx
    movl    -8(%rbp), %eax
    movl    %eax, %esi
    movl    $.LC0, %edi
    movl    $0, %eax
    call    printf
    movl    $0, %eax
    leave
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE0:
    .size   main, .-main
    .globl  swap
    .type   swap, @function
swap:
.LFB1:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    movq    %rdi, -24(%rbp)
    movq    %rsi, -32(%rbp)
    movq    -24(%rbp), %rax
    movl    (%rax), %eax
    movl    %eax, -4(%rbp)
    movq    -32(%rbp), %rax
    movl    (%rax), %edx
    movq    -24(%rbp), %rax
    movl    %edx, (%rax)
    movq    -32(%rbp), %rax
    movl    -4(%rbp), %edx
    movl    %edx, (%rax)
    popq    %rbp
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE1:
    .size   swap, .-swap
    .ident  "GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4"
    .section    .note.GNU-stack,"",@progbits

参照渡しができない言語の場合、言語仕様として参照表現がないというだけで、参照渡しは使われています。

パラメータが値渡しされる場合は、汎用レジスタに値がロードできるもの、具体的には整数や浮動小数点数が値渡しになり、汎用レジスタに値がロードできないもの、具体的には配列や一般のオブジェクトが参照渡しになります。

したがって、参照渡しされる型を利用すれば、swap 関数と同様の機能が実現できます。

つぎのコードは JavaScript で参照渡しと同様の機能を実現する例です。配列は参照渡しなので、swap 関数により２つのパラメータの中身が交換されます。

'use strict';

const swap = (x, y) => {
    let u = x[0];
    x[0] = y[0];
    y[0] = u;
};

var a = [0];
var b = [1];

swap(a, b);

console.log("%i, %i", a, b);

–