Gebruikt iemand alleen maar referentievariabelen om de efficiëntie te vergroten en de omvang te verminderen?

Als sommigen van jullie het nog niet gemerkt hebben, ben ik een noob. Met dat gezegd, hier is mijn vraag:

Heeft iemand van jullie ervaren programmeurs die gebruik maken van referentievariabelen om het geheugen van je programma's te verminderen? Ik dacht dat, hoewel waarschijnlijk een gevaarlijke praktijk, je referentievariabelen voor mobiele applicaties zou kunnen gebruiken om ze minder geheugen te laten gebruiken en ze sneller te maken.

I know that in C++ when you pass a variable, as an argument, to a function that it creates a copy of that variable, but you can use the & to make it a reference variable which just points to the variables memory location. Wouldn't that make your program use less memory overall and make things faster?

1
Wat een ongeveer char (size == 1) versus een verwijzing naar char (grootte == 4 of 8 meestal)?
toegevoegd de auteur Paul R, de bron
Uw uitgangspunt is verkeerd - u suggereert dat het gebruik van verwijzingen het geheugengebruik verlaagt, maar voor het doorgeven van een char by value is 1 byte vereist, terwijl voor het doorgeven van een char door verwijzing een adres vereist (meestal 4 of 8 bytes), om nog maar te zwijgen over een latere de-reference om de waarde te krijgen.
toegevoegd de auteur Paul R, de bron
Het hangt af van de architectuur en ABI, maar meestal kunnen waarden worden doorgegeven in registers en/of op de stapel.
toegevoegd de auteur Paul R, de bron
Ik weet niet zeker of ik dit begrijp.
toegevoegd de auteur JeramyRR, de bron
Ik krijg dat deel nu dat is uitgelegd, maar dat is allemaal voorbij. Zonder een variabele als referentie te passeren, moet het programma een nieuwe variabele in het geheugen maken. Heeft het doorgeven van een adres meer geheugen en verwerking nodig dan het creëren van een geheel nieuwe variabele in het geheugen en het onthouden van het adres?
toegevoegd de auteur JeramyRR, de bron

3 antwoord

  1. Voor grote dingen, zoals structs en objecten, gebruikt een verwijzing minder geheugen. De meeste mensen geven deze echter al door als referentie, dus het maakt niet uit voor onze discussie.

  2. Kleinere dingen zoals ints en chars zijn even groot of kleiner dan een referentie. Er is geen geheugenwinst door ze door te geven op basis van referentie ...

  3. ... maar er is een prestatievergoeding, omdat referenties moeten worden afgeleid om de waarde te manipuleren.

  4. Tot slot, pass-by-referentie is meer vatbaar voor bugs dan pass-by-value. Programma's moeten eerst worden gebouwd op juistheid en prestaties op de tweede plaats.

2
toegevoegd
Super goed. Ik had zeker alle onderstaande dingen moeten schrijven.
toegevoegd de auteur iehrlich, de bron
Dank je. Ik wist niet dat er een boete was voor dereferencing. Ik vermoed dat C ++ dat op de achtergrond doet, dus ik besefte niet eens dat het een stap was.
toegevoegd de auteur JeramyRR, de bron

Dit is afhankelijk van (a) de onderliggende architectuur, (b) het framework en (c) de taal die u gebruikt, maar het algemene antwoord is nee - dit is niet de beste (of zelfs algemene) optimalisatiepraktijk en ja - programma's kunnen langzamer (veel langzamer!) werken met uw aanpak.

1
toegevoegd
Leg uit waarom een ​​programma "langzamer" zou kunnen werken als u referenties gebruikt?
toegevoegd de auteur Paul R, de bron
@PaulR: zoals ik al zei, hangt het van sommige dingen serieus af. Gezien x86-architectuur zonder dingen als CLR of JVM, met behulp van iets als C of C ++. U hebt een procedure en u moet er een wchar_t doorgeven, sizeof (wchar_t) = 1 byte. Als u waarde op de stapel plaatst, hoeft u slechts 1 byte te schrijven en 1 byte te lezen. Als u ernaar verwijst op de stapel, moet u 4 bytes schrijven (over sizeof (MAddr) = 4), 4 bytes lezen en indirecte read uitvoeren vanaf het adres dat is opgegeven door deze 4 bytes.
toegevoegd de auteur iehrlich, de bron
Volgend voorbeeld. Is het een goed idee om een ​​lidklasse-instantie van de klasse te maken die is gekoppeld aan de container of daarin is geïnstantieerd? Als u wilt instantiëren, doet u "ClassName objactName" en geeft u de constructor op in de containter-constructor, anders doet u "ClassName * objectRef" en gebruikt u "nieuwe ClassName (...)". Het antwoord is dat de eerste optie beter is voor de compiler, omdat deze offsets kan genereren voor de leden van leden tijdens het compileren (bijvoorbeeld wanneer de accessors inline worden uitgevoerd).
toegevoegd de auteur iehrlich, de bron
Kun je uitleggen waarom ze langzamer zouden werken? Als u de stap overslaat van het maken van een nieuwe variabele, zou dat dan niet sneller werken?
toegevoegd de auteur JeramyRR, de bron

In C-variabelen worden standaard waarden doorgegeven en er is geen voordeel in de meeste gevallen bij het passeren door verwijzing, omdat u nog steeds een waarde doorgeeft (dit is alleen de aanwijzer in plaats van de waarde waarnaar het verwijst). Houd er rekening mee dat een aanwijzer naar een byte groter is dan de byte zelf!

Bij complexere typen zoals arrays en structs geeft C ze standaard door als referentie. Het is inefficiënt om een ​​kopie van een struct te maken om naar een functie over te gaan, tenzij de functie om een ​​of andere reden een eigen kopie van de structuur nodig heeft. Als u wilt doorgeven op basis van referentie, maar u zich zorgen maakt over de functie die uw structuur wijzigt, kunt u het trefwoord const gebruiken om ervoor te zorgen dat het niet kan worden gewijzigd (of op zijn minst niet gemakkelijk).

0
toegevoegd