동적 바인딩과 깊은

Question

나는이 문제에 일하고 있어요

바인딩 -shallow 내가 답변 가지고 : 정적

: 13

동적 바인딩 - 깊은 : 2 < -이 일에 대해 잘 모르겠어요를

동적 바인딩 -shallow : 2 <를 -이 하나

확실 아니에요가 올바른지?

아래 프로그램을 파스칼과 유사한 언어로 생각해보십시오. 언어의 출력은 정적 범위가 무엇입니까? 언어의 출력은 동적 범위가 이고 딥 바인딩을 사용합니까? 언어의 출력은 동적으로 범위가 지정되며 은 얕은 바인딩을 사용합니까?

Program main; 
    x: integer := 2; 
    y: integer := 1; 
procedure f3(z: integer) 
    begin 
     x = z + x + y; 
    end 
procedure f2(p: procedure, z: integer) 
    int x := 5; 
    begin 
       p(z) 
    end 
procedure f1(z: integer) 
     int y := z 
    begin 
    f2(f3,y); 
    end 

begin /* main program */ 
f1(4); 
     print(x) 
end 

Answer 1

정적 스코프 및 동적 범위 - 얕은 바인딩 케이스의 경우 왜 사용하지 않으시겠습니까? 정적 범위와 펄을 사용하여 : 나는 (4 + 2 + 1 인) 7를 얻을

my $x = 2; 
my $y = 1; 
sub f3($) { 
    my $z = shift; 
    $x = $z + $x + $y; 
} 
sub f2($$) { 
    my ($p, $z) = @_; 
    my $x = 5; 
    $p->($z); 
} 
sub f1($) { 
    my $z = shift; 
    my $y = $z; 
    f2(\&f3, $y); 
} 
f1(4); 
print "$x\n"; 

. my을 local으로 변경하면 얕은 바인딩으로 동적 범위를 가져 오므로 예상대로 2이됩니다.

딥 바인딩을 사용하여 동적 범위를 테스트하는 것은 언어가 거의 없기 때문에 까다 롭습니다. this answer a while back에서 스칼라에 대한 참조의 해시를 지나쳐 "직접"딥 바인딩을 구현 한 Perl 코드를 게시했습니다. 같은 방식 사용 :

#!/usr/bin/perl -w 

use warnings; 
use strict; 

# Create a new scalar, initialize it to the specified value, 
# and return a reference to it: 
sub new_scalar($) 
    { return \(shift); } 

# Bind the specified procedure to the specified environment: 
sub bind_proc(\%$) 
{ 
    my $V = { %{+shift} }; 
    my $f = shift; 
    return sub { $f->($V, @_); }; 
} 

my $V = {}; 

$V->{x} = new_scalar 2; 
$V->{y} = new_scalar 1; 

sub f3(\%$) { 
    my $V = shift; 
    my $z = $V->{z};     # save existing z 
    $V->{z} = new_scalar shift;  # create & initialize new z 
    ${$V->{x}} = ${$V->{z}} + ${$V->{x}} + ${$V->{y}}; 
    $V->{z} = $z;     # restore old z 
} 
sub f2(\%$$) { 
    my $V = shift; 
    my $p = shift; 
    my $z = $V->{z};     # save existing z 
    $V->{z} = new_scalar shift;  # create & initialize new z 
    my $x = $V->{x};     # save existing x 
    $V->{x} = new_scalar 5;   # create & initialize new x 
    $p->(${$V->{z}}); 
    $V->{x} = $x;     # restore old x 
    $V->{z} = $z;     # restore old z 
} 
sub f1(\%$) { 
    my $V = shift; 
    my $z = $V->{z};     # save existing z 
    $V->{z} = new_scalar shift;  # create & initialize new z 
    my $y = $V->{y};     # save existing y 
    $V->{y} = new_scalar ${$V->{z}}; # create & initialize new y 
    f2(%$V, bind_proc(%$V, \&f3), ${$V->{y}}); 
    $V->{y} = $y;     # restore old y 
    $V->{z} = $z;     # restore old z 
} 
f1(%$V, 4); 
print "${$V->{x}}\n"; 

__END__ 

을 나는 (4 + 2 + 4 인) 10를 얻을.