მასივები წარმოადგენს კომპიუტერულ პროგრამებში მონაცემთა სტრუქტურირებული შენახვის ერთ – ერთ ყველაზე მეტად გამოყენებულ ფორმას. მათი დამუშავება შეიძლება განხორციელდეს კლასის ალტერნატივით და მეთოდებით და ფუნქციებით. შესაბამისად, ხშირად საჭიროა მასივის გადაცემა ფუნქციაზე. C და C ++ ენები დიდ თავისუფლებას გვთავაზობენ ამ მოქმედების შესრულების მეთოდების არჩევაში.
Ეს აუცილებელია
C და C ++ ენების შემდგენლები
ინსტრუქციები
Ნაბიჯი 1
გადავიდეთ ფიქსირებული ზომის მასივზე. შეცვალეთ ფუნქციის პროტოტიპი, რომ შეიცავდეს შესაბამისი ტიპის არგუმენტს. მაგალითად, ფუნქციის დეკლარაცია, რომელიც პარამეტრად იღებს სამი ელემენტის მთლიანი რიცხვითი მნიშვნელობების მასივს, შეიძლება ასე გამოიყურებოდეს:
ბათილი ArrayFunction (int ნომრები [3]);
ასეთ ფუნქციას ეწოდება მასივი პირდაპირ მასზე არგუმენტის სახით:
ძალადაკარგულია SomeFunction ()
{
int aNumbers = {1, 2, 3};
ArrayFunction (a ნომრები);
}
გადაცემული მონაცემები კოპირებულია სტეკზე. მასივის შეცვლა მოწოდებულ ფუნქციაში არ ცვლის წყაროს.
ნაბიჯი 2
ცვლადი სიგრძის მასივების გადატანა ფუნქციაზე. ამისათვის უბრალოდ არ მიუთითოთ შესაბამისი არგუმენტის განზომილება:
ბათილი ArrayFunction (int ნომრები );
მრავალგანზომილებიანი მასივების გადაცემა შეიძლება მსგავსი გზით (მხოლოდ პირველი "განზომილება" შეიძლება იყოს ცვლადები):
ბათილი ArrayFunction (int ნომრები [3] [2]);
ამ ფუნქციებს ეძახიან ისევე, როგორც პირველ ეტაპზე.
იმისათვის, რომ ფუნქციაში ცვალებადი სიგრძის მასივების სწორად დამუშავება შეძლოთ, ან მკაფიოდ უნდა გაიაროთ მათი ელემენტების რაოდენობა დამატებითი პარამეტრის საშუალებით, ან გამოიყენოთ კონვენციები, რომლებიც აწესებს შეზღუდვას თავად ელემენტების მნიშვნელობებზე (გარკვეული მნიშვნელობა უნდა იყოს მასივის დასრულების ნიშანი).
ნაბიჯი 3
მასივის გადატანა მაჩვენებლის მიხედვით. ფუნქციის არგუმენტი უნდა იყოს მნიშვნელის მაჩვენებელი, მასივის ელემენტების შესაბამისი ტიპით. Მაგალითად:
ბათილია ArrayFunction (int * pNumbers);
ფუნქციაში მონაცემებზე წვდომა შეიძლება განხორციელდეს როგორც მასივის ელემენტებთან მუშაობის აღნიშვნით, ასევე მისამართის არითმეტიკის გამოყენებით:
ბათილი ArrayFunction (int * pNumbers)
{
pNumbers [0] = 10; // 0 ელემენტზე წვდომა
* (pNumbers + 1) = 20; // 1 პუნქტზე წვდომა
}
Ფრთხილად იყავი! მას შემდეგ, რაც ფუნქციას გადაეცემა არა მონაცემთა ასლი, არამედ მასზე მანიშნებელი, ორიგინალი მასივი შეიცვლება.
ამ მეთოდის უპირატესობაა სიჩქარე, გამოთვლითი რესურსების ეკონომია და გარკვეული მოქნილობა. ასე რომ, სამიზნე ფუნქციას შეგიძლიათ დარეკოთ მას მაჩვენებლის მასივის თვითნებურ ელემენტზე გადაცემით:
ძალადაკარგულია SomeFunction ()
{
int aNumbers = {1, 2, 3};
ArrayFunction (a ნომრები); // მთელი მასივი
ArrayFunction (& ნომრები [1]); // მეორე ელემენტიდან დაწყებული
}
ეს მეთოდი ასევე ჩვეულებრივ მოიცავს ხელმისაწვდომი ელემენტების რაოდენობის დამატებით პარამეტრს ან მასივის ტერმინატორის გამოყენებას.
ნაბიჯი 4
გადასცეს მონაცემები ფუნქციას პარამეტრით, რომელიც არის ობიექტი ან მითითება კლასის ობიექტზე, რომელიც ახორციელებს მასივის ფუნქციონირებას. ასეთი კლასები ან კლასის შაბლონები ჩვეულებრივ გვხვდება პოპულარულ ბიბლიოთეკებში და ჩარჩოებში (QVector in Qt, CArray in MFC, std:: vector in STL და ა.შ.).
ხშირად ეს კლასები ახორციელებენ მონაცემთა გაზიარების იმპირულ სტრატეგიას მითითების დათვლით, ღრმა ასლის შესრულება მხოლოდ მონაცემთა შეცვლისას (კოპირება წერაზე). ეს საშუალებას გაძლევთ შეამციროთ გამოთვლითი რესურსების მოხმარება, თუნდაც მასივი ობიექტების მნიშვნელობით გადაცემის შემთხვევაში, ფუნქციების და მეთოდების არგუმენტების საშუალებით:
ბათილი მასივის ფუნქცია (QVector oArray)
{
int nItemCount = oArray.count ();
int nItem = oArray [0];
}
ძალადაკარგულია SomeFunction ()
{
QVector oArray (10);
ამისთვის (int i = 0; i
