Hur smart är kompilatorn?

Hur smart är kompilatorn egentligen när det gäller att återanvända varibler/referenser?

Om man tex skriver:

for (int i=0; i<100; i++){
   MyObject a = new MyObject();
   a.method(i);
}

fattar inte kompilatorn att a kan återanvändas? Eller är det fortfarande bäst att skriva så här?

MyObject a = new MyObject();
for (int i=0; i<100; i++){
   a.method(i);
}

Hur är det i C++? Det är kanske viktigare där?

Jag har nämligen en paint() metod som kallas väldigt många gånger och vet inte om man måste i största möjliga utsträckning använda globala variabler istället för att skapa lokala i metoden...
Tycker ju att kompilatorn borde fatta...

Generellt:
Hur försiktig ska man vara att skapa lokala instanser i metoder som kalla flitigt? Sänker det prestandan?
Känns som att ha en massa globala variabler inte heller är bra eftersom de allokerar minne hela tiden vilket inte lokala varibler gör..

Kompromissfråga, egentligen.
Lokala variabler kan slösa med minne men korta ned exekveringstiden och tvärtom med globala.

Kompilatorn har ingen inbyggd 'AI' (och det bör den absolut inte ha).

Men tänk efter lite. När du skapar ett objekt anropar du en konstruktor, vilket innebär ett hopp till en helt annan adress och extra allokering av minne. När du refererar tilldelar du bara adresser till något som redan är skapat. Så en iteration där ett upprepat anrop med 'new' händer, blir det en hel del allokerande och hoppande i adresser. ;)

Vad det gäller C++ finns det en till en början intressant diskussion om just detta här

Ok!
Men hur hade det varit om jag istället hade deklarerat en variabel och tilldelat ett värde vid varje iteration?

for(int i=0; i<100; i++){
   int k = tilldelavärde();
   //operation med k
}

Fattar inte kompilatorn då att minnet allokerat för k kan återanvändas?

N-Foe skrev:

Ok!
Men hur hade det varit om jag istället hade deklarerat en variabel och tilldelat ett värde vid varje iteration?

for(int i=0; i<100; i++){
   int k = tilldelavärde();
   //operation med k
}

Fattar inte kompilatorn då att minnet allokerat för k kan återanvändas?

Det du gör i detta exempel är att du anropar en adress som ligger utanför det exekverande kodblocket (innebär en del overhead med att ladda in nytt minnesblock). Du använder inte mer minne utan samma minne som en gång allokerades för funktionen 'tilldelavärde' gäller för varje anrop av funktionen.

Såg NU att det var variabeln k du frågade om (läste slarvigt :r). Jag vet inte hur precis Java gör med detta, men du kan ju testa att göra två exempel och kolla på bytekoden om det allokeras mer minne. Jag tror ivf inte att det gör det, utan att samma minne används. Annars hade kompilatorn varit tvungen att dels läsa alla villkor i din forsats och dels avgöra hur många gånger ett nytt k ska allokeras. - Det hade varit intelligent :)

Vad man måste förstå först är i vilken scope (hur översätter man det?) som en variabel existerar.

Om vi har pseudo-koden (inte helt korrekt men ni fattar)

public class Mupp {
    public static int BEER = 0;
    
    public final int foo = 2;
    
    private int bar;
    
    /** Creates a new instance of Mupp */
    public Mupp() {
        int kermit =3 ;
        
        while(true){
         int missPiggy = kermit;        
        }
        
    } 
}

I den här classen har vi tre olika scope.

Den första är class-scope. Det betyder att man kommer åt en variabel oavsett om man har ett objekt eller inte genom att säga Mupp.BEER.

Den andra är object-scope. Det är variabler som instansieras när man har skapat ett objekt. I vårt fall foo och bar. foo är final och delas alltså mellan alla objekt av typen Mupp.

Den tredje är local-scope. Där har vi två varianter. Den ena är metoden main. I den har vi variabeln kermit som bara är tillgänglig inom metoden. Det går inte att referera till den som foo = kermit eftersom foo inte finns före man anropar metoden main.

I main har vi också ett "sub-local-scope" i while-satsen. I denna sats har vi missPiggy som bara kan användas inom whilesatsen.

Så i while-scopet kommer vi åt alla andra variabler i denna klass.

Vad som händer när man kör är att man kommer åt alla variabler i class-scopet när klassen är laddad i klassladdaren. Sedan kommer man åt alla andra object-variabler när man skapat en ny instans av klassen. Det skapas en ny uppsättning varje gång man skapar en ny instans med new.

I metoden main skapas variablerna om varje gång metoden anropas och försvinner när metoden returnerar. Så är det med alla local-scope. Det betyder att även while-scopet skapar om missPiggy varje gång den körs.

Därför ska man undvika att instansiera temporära variabler inne i loopar.

Blev det något klarare?