using arrays with functions c
Allt du behöver veta om matriser med funktioner i C ++:
I denna handledning kommer vi att diskutera hur matriser kan användas med funktioner i C ++. Generellt kan matriser skickas till funktioner som argument på samma sätt som vi skickar variablerna till funktioner.
Men utvärderingen av formella parametrar är lite annorlunda när det gäller matriser. Innan vi faktiskt utforskar överföring av matriser till funktioner måste vi kort diskutera begreppet pekare till en matris.
=> Kontrollera de fördjupade C ++ -utbildningarna här.
Vad du kommer att lära dig:
- Pekare till en matris
- Skicka arrays till funktion
- Återkommande matriser från funktioner
- Slutsats
- Rekommenderad läsning
Pekare till en matris
Tänk på följande array som innehåller de fem första siffrorna i Fibonacci-sekvensen.
int fibSeq(5) = {1,1,2,3,5};Låt oss förklara en pekare fibPtr för att peka på denna matris.
int* fibPtr; fibPtr = fibSeq;När vi skriver ut innehållet i fibPtr blir utgången det första elementet i fibSeq-arrayen. Detta beror på att namnet på matrisen utan hakparenteser utvärderas till en pekare till det första elementet i matrisen. Således i ovanstående exempel pekar namnet “fibSeq” på det första elementet i arrayen “fibSeq”.
Nedan visas en bild av samma:
Som visas i ovanstående bildrepresentation pekar fibPtr mot det första elementet i matrisen. Således kan vi använda pekarens aritmetik för att skriva ut alla element i matrisen genom att bara använda fibPtr.
Till exempel, expression * (fibPtr + 1) kommer att peka på det andra elementet i arrayen och så vidare.
vad är min nätverkssäkerhetsnyckel för verizon hotspot
Låt oss lägga detta i ett program och kontrollera utdata från “fibSeq” och “fibPtr”:
#include #include using namespace std; int main() { int fibSeq(5) = {1,1,2,3,5}; int* fibPtr; fibPtr = fibSeq; cout<<'
fibSeq points to :'<<*fibSeq; cout<<'
fibSeq(0): '<<*fibPtr; cout<<'
fibSeq(1): '<<*(fibPtr + 1); cout<<'
fibSeq(2): '<<*(fibPtr + 2); cout<<'
fibSeq(3): '<<*(fibPtr + 3); cout<<'
fibSeq(4): '<<*(fibPtr + 4); } }Produktion:
fibSeq pekar på: 1
fibSeq (0): 1
fibSeq (1): 1
fibSeq (2): 2
fibSeq (3): 3
fibSeq (4): 5
I exemplet ovan deklarerar vi en pekervariabel fibPtr och låter den sedan peka på arrayen genom att tilldela arrayens namn till fibPtr. När vi gör detta gör vi att fibPtr pekar på det första elementet i arrayen. Sedan skriver vi ut alla värden i en matris med fibPtr.
Skicka arrays till funktion
När vi har att göra med funktioner skickar vi matriser till funktionen på samma sätt som vi skickar variabler till funktion. Men vi passerar inte arrayvariabeln av typen ().
Istället skickar vi pekaren till arrayen, dvs namnet på arrayen som pekar på det första elementet i arrayen. Då är den formella parametern som accepterar den här pekaren faktiskt en arrayvariabel. När vi passerar pekaren kan vi direkt ändra arrayen inuti funktionen.
Tänk på följande program som beräknar kvadraten för varje element av de fem första elementen i Fibonacci-sekvensen för att visa hur en matris passerar för att fungera.
#include #include using namespace std; void fibSeqSquare(int fibSeq()) { for(int i=0;i<5;i++) { fibSeq(i) *= fibSeq(i); } } int main() { int fibSeq(5) = {1,1,2,3,5}; fibSeqSquare(fibSeq); for(int i=0;i<5;i++) { cout<I exemplet ovan beräknar vi kvadraten för varje element i en Fibonacci-sekvens. Denna kvadrat beräknas inuti en funktion. Därför skickar vi arraynamnet till funktionen “fibSeqSquare” medan vi anropar funktionen från main. Inuti funktionen beräknar vi rutorna för varje element.
När vi har skickat referensen till matrisen med hjälp av en pekare, oavsett vilka ändringar vi gör i matrisen inuti funktionen, kommer den att återspegla matrisen. Därför när vi skriver ut matrisen i huvudfunktionen får vi fyrkanterna för varje element som utdata.
I exemplet ovan har vi sett att arrayargumentet (formell parameter) för funktionen fibSeqSquare inte anger storleken på arrayen utan bara fyrkanten (()) för att indikera att det är en array. Detta är ett sätt att specificera arrayargumenten.
Ett annat sätt att specificera arrayargumentet i den formella parameterlistan är att ange storleken på arrayen inom hakparenteserna. Båda argumenten fungerar på samma sätt. Det här är helt enkelt de två sätt som vi anger arrayargumenten.
Följande exempel visar ett Array-argument specificerat med storlek.
#include #include using namespace std; void displayFibSeq(int fibSeq(5)) { for(int i=0;i<5;i++) { cout<Ovanstående exempel har en funktion för att visa Fibonacci-sekvensen. Funktionen har en parameter som en array där vi också har specificerat storleken på arrayen.
Vi kan också skicka flerdimensionella matriser till funktioner på samma sätt som visas ovan.
hur man lägger till svn-förvar i förmörkelse
Återkommande matriser från funktioner
När det gäller att returnera en array från funktion tillåter inte C ++ oss att returnera en hel array från funktionen. Vi kan dock göra en funktion för att returnera en pekare till matrisen. Men det finns en fångst i den.
Tänk på följande kod:
int* funcArray() { int arr(3) = {1,2,3}; return arr; } int main() { int* aryPtr = funcArray(); cout< Även om ovanstående program helt enkelt returnerar pekaren till det första elementet i en array från funktionen, fungerar det inte som förväntat. Vi kan inte garantera att programmet ger oss rätt resultat. Det kan eller inte ger rätt utdata.
Det beror på att vi returnerar den lokala variabeln från funktionen och vi är inte säkra på om den kommer att omfattas när den returneras eller inte.
Således, i ett nötskal, gynnar C ++ inte att matriser returneras från funktioner.
Om vi alls behöver returnera matriser från funktionen måste vi använda någon av följande metoder:
# 1) Återvänder dynamiskt tilldelade matriser
Vi kan returnera arraypekaren från den dynamiskt tilldelade arrayen. Vi använder operatören 'ny' för att dynamiskt fördela matrisen. Eftersom det är en dynamisk matris kommer den att omfattas såvida vi inte tar bort matrisen. Därför kommer programmet att fungera bra när vi returnerar arrayen.
Detta visas i följande exempel.
#include #include using namespace std; int* funcArray() { int* arr = new int(3); arr(0)=1; arr(1)=2; arr(2)=3; return arr; } int main() { int* aryPtr = funcArray(); cout< Produktion:
1 2 3
# 2) Återkommande statiska matriser
Eftersom statiska variabler / matriser har omfattning i hela programmet kan vi också returnera statiska matriser från funktioner. Vi kan ta ett exempel för att demonstrera detta. Detta är detsamma som föregående exempel med den enda skillnaden att vi i det här exemplet har använt en statisk matris istället för den dynamiskt tilldelade matrisen.
#include #include using namespace std; int* funcArray() { static int arr(3); arr(0)=1; arr(1)=2; arr(2)=3; return arr; } int main() { int* aryPtr = funcArray(); cout< Produktion:
1 2 3
Notera : Vi kan också använda en struktur för att slå in matrisen inuti den och sedan returnera den strukturen. På detta sätt returnerar vi naturligtvis en matris från en funktion. Men detta är inte en mycket genomförbar metod för att returnera matriser.
Slutsats
Således har vi i denna handledning diskuterat arrays med avseende på funktioner i detalj. Vi hoppas att denna handledning skulle ha hjälpt till att rensa alla tvivel och missuppfattningar om C ++ - matriser och funktioner.
gratis mp3 musik nedladdningsapp för android
=> Kolla in den perfekta C ++ träningsguiden här.
Rekommenderad läsning