Méthodes statiques et méthodes d'instance en mémoire

Question

Comment ces différents types de méthodes sont-ils traités en mémoire.

J'ai trouvé deux explications différentes à cela:

1. Les méthodes statiques sont une seule fois en mémoire, alors que les méthodes d'instance sont en mémoire plusieurs fois, une pour chaque instance pour gérer les références à membervariables correctement dans chaque cas .

2. Toutes les méthodes ne sont qu'une seule fois en mémoire et les méthodes d'instance n'obtiennent que l'instance de l'objet en tant que paramètre.

Quelle est la méthode utilisée par les différents compilateurs?

Answer 1

La réponse courte, comme l'a dit Johannes, est presque toujours # 2. Les deux n'existeront en mémoire qu'à un seul endroit, mais les méthodes d'instance ont un contexte (qui est essentiellement un argument caché supplémentaire) qui leur donne accès à l'instance. Mais: Certains langages/environnements instancient une fonction qui ressemble (à une lecture naïve du code source) à une fonction plusieurs fois. JavaScript en est un bon exemple: l'objet fonction se referme sur la portée dans laquelle il est défini, donc s'il y a plusieurs portées (comme une fonction appelée plusieurs fois), plusieurs objets fonction distincts en résultent. (Interprètes/JIT-ers peuvent optimiser si le code est reproduit, mais sur le plan conceptuel, il est et les références de fonction diffèrent.)

Voici un exemple en JavaScript:

function foo() { 

    alert("hi there"); 
} 

function buildBar(x) { 

    function bar() { 
     alert(x); 
    } 

    return bar; 
} 

var f1, f2; 

f1 = foo; 
f2 = foo; 
f1(); 
// alerts "hi there" 
f2(); 
// alerts "hi there" 
alert("f1 === f2 ? " + (f1 === f2)); 
// alerts "true", there is only one `foo` 

var b1, b2; 

b1 = buildBar("one"); 
b2 = buildBar("two"); 
b1(); 
// alerts "one" 
b2(); 
// alerts "two" 
alert("b1 === b2 ? " + (b1 === b2)); 
// alerts "false", there are two `bar`s 

Cela devient pertinent dans certaines implémentations des données d'instance "privées" en JavaScript, où les gens définissent les méthodes d'instance dans le constructeur (autant que buildBar définit bar) afin qu'ils aient accès aux variables privées déclarées dans le constructeur. Cela a l'effet désiré (données d'instance privées), mais l'impact de plusieurs instances de fonction - une pour chaque instance de l'objet.

Answer 2

Les deux ne sont en mémoire qu'une seule fois. La seule différence est que les méthodes d'instance obtiennent un autre premier argument: L'instance de la classe elle-même.

Ce existe existent plusieurs fois dans la mémoire (au moins pour .NET) sont des classes génériques et leurs utilisations spécifiques respectifs. Si vous utilisez à la fois un List<int> et un List<string>, vous obtiendrez deux copies JITTED du code, une spécifique à int, une pour string.

Answer 3

Les méthodes d'instance peuvent être virtuelles. Ainsi, pour chaque instance d'exécution d'un objet avec des méthodes virtuelles, l'environnement d'exécution conserve une administration de références aux méthodes virtuelles. Mais les méthodes ne doivent exister qu'une seule fois en mémoire (mais c'est l'environnement d'exécution qui décide combien de fois il charge une méthode en mémoire).

Pour les méthodes non virtuelles, les références peuvent être déterminées au moment du compilateur.