DOUG LLOYD ყველა უფლება.
ახლა მოდით დაძლევის მართლაც დიდი თემაზე, ფუნქციები.
ჯერჯერობით, რა თქმა უნდა, ყველა პროგრამა, რომელიც ჩვენ უკვე წერილობით
უკვე დაწერილი შიგნით ძირითადი.
ისინი საკმაოდ მარტივი პროგრამების.
თქვენ არ უნდა ჰქონდეს ყველა ეს ფილიალები და რამ ხდება.
ჩვენ შეგვიძლია მხოლოდ ჯდება ყველა შიგნით ძირითადი და ეს
არ საშინლად აბსოლუტური.
მაგრამ, როგორც, რა თქმა უნდა გრძელდება და როგორც თქვენ დაიწყოს პროგრამების შემუშავება
დამოუკიდებლად, ისინი ალბათ აპირებს უნდა დაიწყოს მიიღოს გაცილებით მეტი, ვიდრე 10
ან 15 ხაზები.
შესაძლოა ასობით და ათასობით ან ათიათასობით ხაზების კოდი.
და ეს ნამდვილად არ არის რომ გიჟები აზროვნების.
როგორც ასეთი, ეს, ალბათ, არ არის კარგი იდეა შენარჩუნება ყველაფერი შიგნით ძირითადი.
მას შეუძლია მიიღოს ცოტა ძნელია რას ვეძებთ, თუ თქვენ, რომ.
>> საბედნიეროდ, მიუხედავად იმისა, რომ C, და საკმაოდ ბევრი ყველა სხვა პროგრამირების ენა, რომელიც
შეიძლება მუშაობა, საშუალებას გვაძლევს ჩაწერის ფუნქცია.
და მე უბრალოდ აპირებს მიიღოს სწრაფი განზე აქ
უნდა აღინიშნოს, რომ ფუნქციები ერთი ფართობი კომპიუტერულ მეცნიერებაში.
და დაინახავთ მრავალი სხვა, მათ შორის, სხვადასხვა რაოდენობა მთელი კურსი
და თუ გაგრძელდება.
იქ, სადაც არის ბევრი სინონიმები იგივე სიტყვა.
ასე რომ, ჩვენ მოვუწოდებთ ფუნქციები.
მაგრამ თქვენ შესაძლოა, ასევე ისმენს მათ მოხსენიებული, როგორც პროცედურები,
ან მეთოდები, კერძოდ, თუ თქვენ ოდესმე კეთდება ნებისმიერი ობიექტზე ორიენტირებული პროგრამირების
ადრე და არ აღელვებს თუ არ, არა
დიდი deal-- მაგრამ აუდიტის ორიენტირებული ენებზე
ხშირად უწოდებენ მეთოდები.
ზოგჯერ ისინი მოუწოდა subroutines.
მაგრამ ისინი ნამდვილად ყველა ეხება იგივე ძირითადი იდეა.
>> ვნახოთ რა ეს იდეა.
რა არის ფუნქცია?
ისე ფუნქცია მართლაც მეტი არაფერი შავი ყუთი.
შავი ყუთი, რომელსაც აქვს მითითებული ნულოვანი ან მეტი საშუალებებით და ერთი გამომავალი.
ასე მაგალითად, ამ შეიძლება იყოს ფუნქცია.
ეს არის ფუნქცია მოუწოდა func.
და ეს ხდება სამი საშუალებებით a, b და c.
და შიგნით რომ შავი ყუთი, ჩვენ ზუსტად არ ვიცი, რას აკეთებს,
მაგრამ ეს პროცესები საშუალებებით რამდენიმე გზა და მაშინ იგი
იძლევა ერთი გამომავალი, ამ შემთხვევაში, z.
ახლა, რომ ეს პატარა ნაკლები აბსტრაქტული, ჩვენ
შეიძლება ითქვას, რომ, შესაძლოა, გვაქვს ფუნქცია მოუწოდა
დავამატებთ, რომ იღებს სამ საშუალებებით a, b, და გ და ამუშავებს გამომავალი რამდენიმე გზა
შიგნით შავი ყუთი წარმოების ერთი გამომავალი.
ასე რომ, ამ შემთხვევაში, თუ რჩეულებში იღებს 3, 6, და 7.
სადღაც შიგნით რჩეულებში ფუნქცია, ჩვენ გვინდა
ველით, რომ ისინი დაემატება ერთად წარმოების გამომავალი, რომელიც
3 + 6 + 7 და 16.
>> ასევე, თქვენ გაქვთ ფუნქცია მოუწოდა mult რომელიც იღებს ორ საშუალებებით, და ბ,
ამუშავებს მათ რამდენიმე გზა, როგორიცაა რომ გამომავალი ფუნქცია
პროდუქტი ორ საშუალებებით.
ორ საშუალებებით მრავლდება ერთად.
4 და 5 მიმდინარეობს შევიდა mult, რაღაც ხდება, გამომავალი ჩვენ ველით,
20.
რატომ ეძახით შავი ყუთი?
თუ ჩვენ არ წერა ფუნქციონირებს საკუთარ თავს, რომელიც
ჩვენ გავაკეთეთ საკმაოდ მწირი ჯერჯერობით CS50.
ჩვენ ვნახეთ ბეჭდვითი F, მაგალითად, რომელიც არის ფუნქცია, რომელიც ჩვენ არ წერენ
საკუთარ თავს, მაგრამ ჩვენ არ გამოიყენონ ყველა დროის.
თუ ჩვენ არ წერდა ფუნქციების საკუთარ თავს,
ჩვენ ნამდვილად არ უნდა იცოდეს, თუ როგორ ეს რეალურად განხორციელდება ქვეშ hood.
>> ასე მაგალითად, შავი ყუთი მე უბრალოდ აჩვენა თქვენ გამრავლება,
mult a, b შეიძლება იყოს defined-- და ეს არის მხოლოდ
ზოგიერთი pseudocode-- შეიძლება იყოს განისაზღვრება, როგორც გამომავალი ჯერ ბ.
ეს აზრი, მარჯვნივ.
თუ ჩვენ გვაქვს ფუნქცია მოუწოდა mult რომელიც იღებს ორ საშუალებებით.
ჩვენ ველით, რომ გამომავალი გვინდა იყოს ორ საშუალებებით მრავლდება ერთად,
ჯერ ბ.
მაგრამ mult ასევე შეიძლება იყოს განხორციელებული, როგორც ეს,
ჩვენ გვაქვს counter ცვლადი მისაღებად შეიქმნა შიგნით mult 0.
და მაშინ ჩვენ ვიმეორებ ეს პროცესი ბ-ჯერ დაამატოთ კონტრშეტევებზე.
მაგალითად, თუ ჩვენ ვამრავლებთ 3 ა მოძებნა 5 ბ, შეიძლება ითქვას, მითითებული counter 0,
ვიმეორებ, ხუთჯერ, დაუმატეთ 3 კონტრშეტევებზე.
ასე რომ, ჩვენ ვიწყებთ 0 და შემდეგ ვაკეთებთ ეს ხუთჯერ 3, 6, 9, 12, 15.
ეს არის იგივე შედეგი. ჩვენ ჯერ კიდევ 3 ჯერ 5 მხოლოდ
განხორციელების განსხვავებულია.
>> ეს არის ის, რაც ჩვენ ნიშნავს, როდესაც ჩვენ ვამბობთ, შავი ყუთი.
ეს მხოლოდ იმას ნიშნავს, რომ ჩვენ ნამდვილად არ აღელვებს როგორ ეს განხორციელებული ქვეშ hood
რადგან გამომავალი არის ის, რაც ჩვენ ველით.
ფაქტობრივად, ეს არის ის, ხელშეკრულების ნაწილი გამოყენების ფუნქციები, კერძოდ,
ფუნქციები, რომელიც სხვები წერენ.
ქცევა ყოველთვის აპირებს რომ ტიპიური, არაპროგნოზირებადი
საფუძველზე სახელით ფუნქცია.
ამიტომაც არის, რომ ეს მართლაც მნიშვნელოვანია, როდესაც თქვენ ჩაწერის ფუნქცია
ან როდესაც სხვა ადამიანები წერენ ფუნქციები, რომელიც შეიძლება გამოიყენოს,
რომ იმ ფუნქციები აქვს ნათელი, შედარებით აშკარა სახელები,
და კარგად არის დოკუმენტირებული.
რა არის, რა თქმა უნდა იმ შემთხვევაში, ფუნქცია, როგორიცაა ბეჭდვითი ვ.
>> რატომ ჩვენ ვიყენებთ ფუნქციებს?
ისე, როგორც მე ვთქვი ადრე, თუ ჩვენ წერენ ყველა ჩვენი კოდი შიგნით ძირითადი რამ
შეიძლება ნამდვილად რთული და მართლაც რთულია.
ფუნქციები საშუალებას გვაძლევს უნარი ორგანიზება რამ და გაწყვეტის
ძალიან რთული პრობლემაა შევიდა ბევრი უფრო მართვადი ქვე ნაწილები.
ფუნქციები ასევე საშუალებას მოგვცემს გაამარტივებს კოდირების პროცესი.
ეს ბევრი ადვილია გამართვის 10 ხაზის ფუნქცია წინააღმდეგ 100 ონლაინ
ფუნქცია ან 1000 ხაზი ფუნქციონირებს.
თუ ჩვენ მხოლოდ უნდა გამართვის პატარა ნაჭრები დროს,
ან ჩაწერის პატარა ნაჭრები დროს, ეს ქმნის, რომ პროგრამირების გამოცდილება
უკეთესი.
მერწმუნეთ, რომ ერთი.
>> და ბოლოს, თუ ჩვენ წერენ ფუნქცია ჩვენ შეგიძლიათ reuse იმ სხვადასხვა კუთხეში.
ფუნქციები შეიძლება რეციკლირებული.
ისინი შეიძლება გამოყენებულ იქნას ერთი პროგრამა, ან სხვა.
თქვენ უკვე დაწერილი ფუნქცია, თქვენ
უნდა გავაკეთოთ გითხრათ, რომ პროგრამა სად უნდა იპოვოს, რომ ფუნქცია.
ჩვენ უკვე გადამუშავება და გამოყენების ბეჭდვითი ვ მეტი 40 წლის განმავლობაში.
მაგრამ ეს იყო მხოლოდ წერილობითი ერთ დროს.
საკმაოდ სასარგებლო, მარჯვნივ.
ყველა უფლება.
ასე რომ, ფუნქციების დიდი.
ჩვენ ვიცით, რომ.
ახლა დავიწყოთ წერა მათ.
მოდით დავიწყოთ მათ ჩვენი პროგრამები.
იმისათვის, რომ გავაკეთოთ, რომ პირველი რასაც ვაკეთებთ არის განაცხადოს ფუნქცია.
როდესაც თქვენ გამოაცხადოს ფუნქცია რაც თქვენ ძირითადად აკეთებს
ეუბნება შემდგენელი, hey, ასე რომ თქვენ იცით,
მე ვაპირებ წერა ფუნქცია მოგვიანებით
და აქ რა ის აპირებს გამოიყურებოდეს.
ამის მიზეზი არის იმიტომ, რომ შემდგენლები შეუძლია
ამის რაღაც უცნაური რამ, თუ ხედავენ კომპლექტი სიმბოლოები
რომ ისინი არ იცნობს.
ასე რომ, ჩვენ მხოლოდ მისცეს შემდგენელი ხელმძღვანელობს, მე შექმნის ფუნქცია
და ის აპირებს ამის გაკეთება.
ფუნქციის განსაზღვრა, ზოგადად, თუ თქვენ ორგანიზება თქვენი კოდი ისე,
რომ სხვები შეძლებენ მესმის და გამოიყენოს,
ზოგადად მინდა დააყენოს ყველა თქვენი ფუნქცია დეკლარაციების
ძალიან ზევით თქვენი კოდი, მარჯვენა სანამ დაიწყება წერილობით მთავარი კი.
და მოხერხებულად, არსებობს ძალიან სტანდარტული ფორმა
რომ ყველა ფუნქცია დეკლარაცია შემდეგნაირად.
ისინი ყველა საკმაოდ ბევრი მოსწონს ეს.
არსებობს სამი ნაწილებით ფუნქცია დეკლარაცია, დაბრუნების ტიპის, სახელი,
და არგუმენტი სიაში.
>> ახლა დაბრუნების ტიპის, თუ რა სახის ცვლადი ფუნქციის გამომავალი.
ასე მაგალითად, თუ ჩვენ ვფიქრობთ უკან წუთის წინ რომ გამრავლებით ორი
ნომრები ფუნქცია, რას შეიძლება ველოდოთ, თუ გავამრავლებთ რიცხვი მიერ მთელი რიცხვი
გამომავალი იქნება ალბათ რიცხვი, მარჯვნივ.
მრავლდება ორი რიცხვებით ერთად, თქვენ რიცხვი.
ასე რომ, დაბრუნების ტიპის, რომ ფუნქცია იქნება int.
სახელი რა გსურთ მოვუწოდებთ ფუნქცია.
ეს, ალბათ, ყველაზე ნაკლებად მნიშვნელოვანი ნაწილი ფუნქცია დეკლარაცია,
თვალსაზრისით ფუნქციონირება.
მაგრამ რეალურად ალბათ ერთ ყველაზე მნიშვნელოვანი ნაწილი
ფუნქციის დეკლარაციის თვალსაზრისით იცის, რა ფუნქცია რეალურად
აკეთებს.
თუ დაასახელებთ ფუნქცია f და g ან თ ან საიდუმლო ან რამე მაგდაგვარს,
თქვენ ალბათ აპირებს მიიღოს პატარა ეთამაშა ცდილობს
უნდა გვახსოვდეს, რა იმ ფუნქციებს გააკეთოს.
ასე რომ, ეს მნიშვნელოვანია, რათა თქვენი ფუნქციის მნიშვნელოვანი სახელები.
>> და ბოლოს, არგუმენტი სიაში მძიმით გამოყოფილი
ყველა საშუალებებით თქვენს ფუნქცია, რომელთაგან თითოეული აქვს ტიპის და სახელი.
ასე არა მხოლოდ თქვენ უნდა დააკონკრეტა, თუ რა ტიპის ცვლადი
ფუნქცია დაბეჭდავს, თქვენ ასევე მინდა დააკონკრეტა
რა ტიპის და სახის ცვლადები ფუნქცია იქნება მიღების საშუალებებით.
ასე რომ, მოდით მაგალითად აქ.
მოდით უბრალოდ შეხედეთ უფრო კონკრეტული ერთი.
ასე რომ, აქ არის მაგალითი ფუნქცია დეკლარაციის ფუნქცია, რომელიც
რომ დაამატოთ ორი რიცხვებით ერთად.
თანხა ორ რიცხვებით აპირებს იყოს მთელი, ისევე, როგორც ჩვენ მხოლოდ
განიხილეს.
ასე რომ, დაბრუნების ტიპის, აქ მწვანე, იქნება int.
ეს უბრალოდ გვეუბნება, რომ დაამატოთ ორი ints აპირებს, ბოლოს დღეს,
გამომუშავება, ან შამფურზე ის უკან იმისათვის, რომ ჩვენთვის, მთელი რიცხვი.
იმის გათვალისწინებით, თუ რა ეს ფუნქცია ჯერ ჩვენ მინდა ეს მნიშვნელოვანი სახელი.
რჩეულებში ორი ints, როგორც ჩანს, საჭიროების შემთხვევაში, იმის გათვალისწინებით,
ჩვენ აღების ორი რიცხვებით საშუალებებით და იმედია დასძინა, რომ მათ ერთად.
ეს შეიძლება იყოს ცოტა cumbersome სახელი და გულწრფელად ეს ფუნქცია
ალბათ არ არის საჭირო მას შემდეგ, რაც ჩვენ გვაქვს დამატებით
ოპერატორი, თუ გახსოვთ, ჩვენი განხილვა ოპერატორები, ადრე.
მაგრამ მოდით უბრალოდ, ვამბობთ, რომ გულისთვის არგუმენტი, რომ ეს ფუნქცია სასარგებლო
და ამიტომ ჩვენ მოვუწოდებთ მას დავამატებთ ორ ints.
და ბოლოს, ეს ფუნქცია იღებს ორ საშუალებებით.
რომელთაგან თითოეული არის მთელი რიცხვი.
ასე რომ, ჩვენ ამ მძიმე გამოყოფილი საშუალებებით.
ახლა ჩვენ ზოგადად მინდა მისცეს სახელი თითოეული მათგანი
ისე, რომ ისინი შეიძლება გამოყენებულ იქნას ფარგლებში ფუნქცია.
სახელები არ ვართ საშინლად მნიშვნელოვანია.
>> ამ შემთხვევაში, ჩვენ არ ემთხვეოდეს რაიმე მნიშვნელობა აქვს მიმაგრებული.
ასე რომ ჩვენ შეგვიძლია უბრალოდ მოვუწოდებთ მათ და ბ.
რომ სრულიად ჯარიმა.
მაგრამ, თუ, თქვენთვის თავს სიტუაციაში,
სადაც სახელები ცვლადები შეიძლება რეალურად იყოს მნიშვნელოვანი,
თქვენ მინდა მოვუწოდო მათ რაღაც გარდა და ბ
მისცეს მათ რაღაც უფრო სიმბოლურად მნიშვნელოვანი.
მაგრამ ამ შემთხვევაში, ჩვენ ნამდვილად არ ვიცი არაფერი ფუნქციის შესახებ.
ჩვენ უბრალოდ გვინდა, რომ ორ რიცხვებით.
ასე რომ, ჩვენ უბრალოდ ვუწოდებთ იმ რიცხვებით და ბ.
ეს არის ერთ-ერთი მაგალითია.
>> რატომ არ მიიღოს მეორე ვფიქრობ, რომ ამ ერთი,
როგორ ფიქრობთ, დაწერეთ ფუნქცია დეკლარაციის ფუნქცია, რომელიც
მრავლდება ორი მცურავი პუნქტიანი ნომრები?
გახსოვთ, რა მცურავი წერტილი ნომერი?
რა ამ ფუნქციის დეკლარაციის ჰგავს?
მე რეალურად გირჩევთ პაუზის ვიდეო აქ და მიიღოს, თუ რამდენი დრო გჭირდებათ.
დაფიქრდით, რა ეს ფუნქცია დეკლარაცია იქნება?
რა დაბრუნების ტიპის იქნება?
რა აზრიანი იყოს სახელი?
რა საშუალებებით უნდა იყოს?
ასე რომ, რატომ არ პაუზის ვიდეო აქ და წერა-მდე ფუნქცია დეკლარაცია
ერთი ფუნქცია, რომელიც გამრავლების ორი მცურავი პუნქტიანი ნომრები ერთად.
იმედია თქვენ ათვისება ვიდეო.
>> მოდით შევხედოთ მაგალითად ერთ-ერთი შესაძლო დეკლარაცია.
Float mult ორი reals float x, float y.
პროდუქტი ორი მცურავი პუნქტიანი ნომრები,
რომელიც გავიხსენოთ როგორ ჩვენ წარმოადგენს რეალური ციფრები
ან ნომრები ათობითი ღირებულებების c, იქნება მცურავი პუნქტიანი ნომერი.
როცა გამრავლებით ათობითი მიერ ათობითი,
თქვენ ალბათ აპირებს მიიღოს ათობითი.
გსურთ მისცეს მას შესაბამისი სახელი.
გაამრავლეთ ორი reals, როგორც ჩანს, ჯარიმა.
მაგრამ თქვენ ვერ ნამდვილად ეძახით mult ორი მოძრავი, ან mult მოძრავი.
არაფერი, რადგან ეს მისცა ნამდვილი მნიშვნელობა, თუ რა
ამ შავი ყუთი ამის გაკეთებას აპირებდა.
ისევ და ისევ, ამ შემთხვევაში, ჩვენ არ როგორც ჩანს, აქვს რაიმე მნიშვნელობა ერთვის
to სახელები ცვლადები ჩვენ გავლის,
ასე რომ, ჩვენ უბრალოდ მოვუწოდებთ მათ x და y.
ახლა, თუ თქვენ მოვუწოდებთ მათ რაღაც სხვა, რომელიც სრულიად ჯარიმა.
სინამდვილეში, თუ თქვენ არ ამ დეკლარაციის ნაცვლად
გამოყენებით ორადგილიანი ნაცვლად მოძრავი, თუ გავიხსენებთ
რომ ორადგილიანი სხვადასხვა გზა უფრო ზუსტად
დააკონკრეტა რეალური ნომრები ან მცურავი პუნქტიანი ცვლადები.
რომ სრულიად ჯარიმა ძალიან.
ან ერთ-ერთი იმ იქნება ჯარიმა.
ფაქტობრივად, არსებობს რამდენიმე სხვადასხვა კომბინაციები
გზები, რათა განაცხადოს ამ ფუნქციას.
მაგრამ ეს ორი საკმაოდ კარგი პირობა.
ჩვენ განაცხადა ფუნქცია, რომელიც არის დიდი.
ჩვენ განუცხადა შემდგენელი, რაც მას არის ის, რაც ჩვენ ვაპირებთ იყოს აკეთებს.
ახლა მოდით რეალურად წერენ, რომ ფუნქცია.
მოდი, განმარტება, ისე, რომ შიგნით შავი ყუთი
პროგნოზირებადი ქცევის ხდება.
ფაქტობრივად, ჩვენ ვამრავლებთ ორი რეალური ნომრები ერთად, და დასძინა ნომრები
ერთად, ან აკეთებს რაც არ არის რომ ჩვენ ვთხოვეთ ჩვენი ფუნქცია უნდა გააკეთოს.
>> ასე რომ, ფაქტობრივად, მოდით ცდილობენ და განსაზღვროს გავამრავლოთ ორი reals რომელიც ჩვენ მხოლოდ
ისაუბრა მეორე წინ.
ახლა დასაწყისში ფუნქცია განმარტება
გამოიყურება თითქმის ზუსტად იგივე როგორც ფუნქცია დეკლარაცია.
მე ორივე მათგანი აქ.
ზედა არის ფუნქცია დეკლარაცია, ტიპის, სახელი, მძიმით გამოყოფილი არგუმენტი
სია, მძიმით.
მძიმით მიუთითებს, რომ რომ არის ფუნქცია დეკლარაცია.
დასაწყისში ფუნქცია განმარტება გამოიყურება თითქმის ზუსტად
იგივე ტიპის, სახელი, მძიმეებით არგუმენტი სიაში, არ მძიმით,
გახსნა Curly გაუწიოს.
ღია Curly გაუწიოს, ისევე, როგორც ჩვენ ვაკეთებთ ძირითად,
იმას ნიშნავს, რომ ჩვენ ახლა იწყება განსაზღვროს
რა ხდება შიგნით შავი ყუთი რომ ჩვენ გადავწყვიტეთ, მოვუწოდებთ mult ორი reals.
აქ არის ერთი გზა, რათა განახორციელოს იგი.
ჩვენ შეგვიძლია ვთქვათ, ჩვენ შეიძლება განაცხადოს ახალი ცვლადი ტიპის float მოუწოდა პროდუქტი
და მივანიჭოთ, რომ ცვლადი ღირებულება x ჯერ y.
ხოლო შემდეგ დაბრუნდნენ პროდუქტი.
რას დაბრუნების ნიშნავს აქ.
ისე დაბრუნების გზა ჩვენ მიუთითებს იმაზე, რომ ის, თუ როგორ
ჩვენ ავლით გამომავალი უკან out.
ასე რომ დაბრუნდეს რაღაც, არის იგივე, რაც, ეს არის გამოშვება შავი ყუთი.
ასე რომ, თუ როგორ გავაკეთოთ ეს.
აქ არის კიდევ ერთი გზა განახორციელოს იგი.
ჩვენ შეგვიძლია მხოლოდ დაბრუნების x ჯერ y.
x არის float.
y არის float.
ასე რომ, x ჯერ y ასევე float.
ჩვენ კი არ უნდა შექმნა კიდევ ერთი ცვლადი.
ასე რომ, სხვა გზა განახორციელოს ზუსტად იგივე შავი ყუთი.
>> ახლა ერთი წუთით, პაუზის ვიდეო, კიდევ ერთხელ,
და ცდილობენ და განსაზღვროს რჩეულებში ორი ints, რაც სხვა ფუნქცია, რომ ჩვენ
ისაუბრა მომენტში წინ.
კიდევ ერთხელ, მე დააყენა ფუნქცია დეკლარაცია, და ასე მძიმით,
და ღია Curly გაუწიოს და დახურული curly
გაუწიოს მიუთითოს, სადაც ჩვენ შევსება შინაარსი რჩეულებში ორი ints,
ასე, რომ ჩვენ განსაზღვროს კონკრეტული ქცევა შიგნით შავი ყუთი.
ასე რომ პაუზის ვიდეო.
და მიიღოს როგორც ბევრი დრო თქვენ უნდა ცდილობენ და განსაზღვროს
განხორციელების რჩეულებში ორი ints, როგორიცაა რომ როდესაც ფუნქცია შედეგები მნიშვნელობა,
ეს ასეა, ფაქტობრივად, დაბრუნების თანხა ორ საშუალებებით.
ასე რომ, ისევე როგორც წინა მაგალითად, არსებობს რამდენიმე გზა
რომ თქვენ შეიძლება განახორციელოს რჩეულებში ორი ints.
აქ არის ერთი.
აქ ფორთოხლის მე უბრალოდ გვქონდა comments--
მე უბრალოდ დასძინა ზოგიერთი კომენტარი მიუთითოს
რა ხდება თითოეული ხაზი კოდი.
ასე რომ, მე ვაცხადებ, ცვლადი მოუწოდა თანხა ტიპის int.
მე ვიტყვი, თანხა შეადგენს a + b.
სწორედ იქ, სადაც ჩვენ რეალურად აკეთებს მუშაობა და დასძინა, რომ A და B ერთად.
და მე დაბრუნებას თანხა.
და რომ აზრი, რადგან თანხა არის ცვლადი ტიპის int.
და რა არის მონაცემთა ტიპის, რომ ეს ფუნქცია მეუბნება, რომ ის აპირებს გამომავალი?
Int.
ასე რომ, მე დაბრუნების თანხა, რომელიც არის მთელი რიცხვი ცვლადი.
და რომ აზრი იმის გათვალისწინებით, რაც ჩვენ განაცხადა და განისაზღვრება ჩვენი ფუნქცია
ამის გაკეთება.
>> ახლა თქვენ შეგიძლიათ განსაზღვროთ ფუნქცია ამ გზით,
int თანხა შეადგენს პლუს ბ გამოტოვოთ, რომ პირველი step-- და შემდეგ, დაბრუნებას თანხა.
ახლა თქვენ შეიძლება ასევე განხორციელებული ეს გზა,
რომელიც უაღრესად არ ვურჩევ.
ეს არის ცუდი სტილი ერთი რამ და ნამდვილად ცუდი დიზაინი,
მაგრამ ეს იმას, ფაქტობრივად, მუშაობა.
თუ ეს კოდი, რომელიც არის int რჩეულებში ცუდი გველგესლა dot გ, და გამოიყენოთ იგი.
ეს რეალურად არ დაამატოთ ორი რიცხვებით ერთად.
ეს არის ძალიან ცუდი განხორციელება ამ კონკრეტული ქცევა.
მაგრამ ეს არ იმუშავებს.
ეს მხოლოდ აქ საილუსტრაციოდ იმ თვალსაზრისით, რომ ჩვენ ნამდვილად არ
მაინტერესებს, რა ხდება შიგნით შავი ყუთი, მანამ,
როგორც ეს აქვს გამომავალი, რომ ჩვენ ველით.
ეს არის ცუდად შექმნილია შავი ყუთი.
მაგრამ ბოლოს დღეს, ეს იმას კიდევ გამომავალი თანხა a + b.
ყველა უფლება.
ასე რომ, ჩვენ განაცხადა ფუნქციები.
და ჩვენ განსაზღვრული ფუნქცია.
ასე რომ, ძალიან კარგი.
ახლა მოდით დავიწყოთ გამოიყენოთ ფუნქცია რომ ჩვენ განაცხადა და ჩვენ განსაზღვრული.
მოვუწოდებთ ფუნქცია ეს, ფაქტობრივად, საკმაოდ easy-- ყველა თქვენ უნდა გავაკეთოთ
არის გაიაროს ეს შესაბამისი არგუმენტები, არგუმენტები მონაცემები ტიპის
რომ ელოდება და მაშინ მივანიჭოთ დაბრუნების
ღირებულება რომ ფუნქცია და ამას საბაბი ჩემთვის
მივანიჭოთ დაბრუნების ღირებულება, რომ ფუნქცია რაღაც სწორი ტიპის.
>> მოდით აქვს შევხედოთ ამ პრაქტიკაში ფაილი
მოუწოდა გველგესლა 1 dot გ, რომელიც მაქვს ჩემი cs50 IDE.
ასე რომ, აქ არის გველგესლა 1 dot გ.
დასაწყისში თქვენ ვხედავ მე ჩემი მოიცავს, ფუნტი მოიცავს,
სტანდარტული IO, და cs50 dot თ.
და მაშინ მე მაქვს ჩემი ფუნქცია დეკლარაცია.
ეს არის სადაც მე ვარ ვეუბნებოდი შემდგენელი ვარ
იქნება წერა ფუნქცია მოუწოდა რჩეულებში ორი ints.
ის აპირებს დაბეჭდავს მთელი ტიპის ცვლადი.
სწორედ ამ ნაწილში არის სწორი აქ.
და მაშინ მე მაქვს ორი საშუალებებით, რომ იგი და ბ, რომელთაგან თითოეული არის მთელი რიცხვი.
შიგნით ძირითადი ვთხოვ მომხმარებელს შეყვანის განაცხადა, მომეცი რიცხვი.
და ისინი აიძულა დაგავიწყდეთ int, რომელიც არის ფუნქცია, რომელიც
შედის CS50 ბიბლიოთეკა.
და რომ იღებს შენახული x, რიცხვი ცვლადი.
>> მაშინ ჩვენ შეეკითხება მათ კიდევ ერთი რიცხვი.
ჩვენ კიდევ ერთი რიცხვი და შესანახად, რომ y.
და მაშინ, აქ ხაზი 28, არის სადაც ჩვენ ჩვენი ფუნქცია ზარი.
ჩვენ ვამბობთ, int z ტოლობის რჩეულებში 2 ints x მძიმით y.
მიგაჩნიათ თუ არა, თუ რატომ ეს აზრი?
x არის მთელი ტიპის ცვლადი და y არის მთელი ტიპის ცვლადი.
ასე რომ, კარგი.
ეს აზრი, რასაც ჩვენი ფუნქცია დეკლარაციის on line 17 ჰგავს.
მძიმით გამოყოფილი შეყვანის სია ელის ორი რიცხვებით, და ბ.
იმ შემთხვევაში, ჩვენ შეგვიძლია ვუწოდოთ მათ, რაც ჩვენ გვინდა.
უბრალოდ ელის ორი რიცხვებით.
და x არის რიცხვი და y არის მთელი რიცხვი.
რომ მუშაობს.
>> ჩვენ ვიცით, რომ ფუნქციის აპირებს რომ დაბეჭდავს რიცხვებით ისევე.
ასე რომ, ჩვენ შენახვის გამომავალი ფუნქციის,
რჩეულებში ორი ints, რიცხვი ტიპი ცვლადი, რომელიც ჩვენ მოუწოდებდა z.
და მაშინ ჩვენ შეგვიძლია ვთქვათ, რომ თანხა პროცენტი მე და პროცენტი ი პროცენტს i.
x, y და z შესაბამისად შევსების იმ პროცენტს i ს.
რა არის განმარტება რჩეულებში ორი ints გამოიყურებოდეს?
ეს არის საკმაოდ მარტივი.
ეს არის ერთ ერთი პირობა ჩვენ უბრალოდ დაინახა მეორე წინ,
int თანხა შეადგენს a + b დაბრუნების თანხა.
მუშაობს ეს?
მოდით ფაილის შენახვა.
და შემდეგ ქვევით აქ ჩემი ტერმინალის მე ვაპირებ, რომ გველგესლა 1,
და მე გარკვევა ჩემი ეკრანზე.
მე ვაპირებ, რომ მიუახლოვდით, რადგან ვიცი, ეს არის პატარა ძნელია ვხედავ.
>> ასე რომ, ჩვენ შეადგინონ ამ პროგრამის როგორც გველგესლა 1.
ასე რომ, ჩვენ შეგვიძლია გავაკეთოთ dot slash გველგესლა 1.
მომეცი რიცხვი, 10.
მომეცი კიდევ ერთი რიცხვი, 20.
თანხა 10 და 20 30.
ასე რომ, ჩვენ წარმატებული ფუნქცია ზარი.
თქვენ შეგიძლიათ აწარმოებს ფუნქცია ისევ, უარყოფითი 10, 17 თანხა უარყოფითი 10 და 17 7.
ეს ფუნქცია.
მას აქვს ქცევის ჩვენ ველით, რომ ეს.
ასე რომ, ჩვენ წარმატებული ფუნქცია, განმარტება, დეკლარაცია,
და წარმატებული ფუნქცია ზარი.
Couple სხვადასხვა რაოდენობა ფუნქციების შესახებ
სანამ ჩვენ დადოს ამ მონაკვეთზე.
შეგახსენებთ, ჩვენი განხილვა მონაცემთა ტიპები,
ადრე, რომ ფუნქციები შეიძლება ზოგჯერ არ საშუალებებით.
თუ ეს საქმე, ჩვენ ვაცხადებ ფუნქციის
მქონე ბათილად არგუმენტი სიაში.
გახსოვთ, თუ რა ყველაზე გავრცელებული ფუნქცია
ჩვენ ვხედავთ, ჯერჯერობით, რომელიც იღებს ბათილად არგუმენტი სიაში?
ეს არის მთავარი.
შეგახსენებთ ასევე, რომ ფუნქცია ზოგჯერ არ რეალურად გამომუშავება.
იმ შემთხვევაში, ვაცხადებთ ფუნქცია მქონე ბათილად დაბრუნების ტიპის.
მოდით დადონ ამ განყოფილებაში ბრძოლა პრაქტიკა პრობლემა.
>> ასე რომ, აქ არის პრობლემა ასახული.
მე მინდა, რომ წერენ ფუნქცია მოუწოდა მოქმედებს სამკუთხედის.
რა ამ ფუნქციის უნდა გააკეთოს მიიღოს სამი რეალური ციფრები
რომელიც წარმოადგენს lengths სამი მხარეებმა სამკუთხედის როგორც მისი პარამეტრები,
ან მისი არგუმენტები, ან მისი საშუალებებით კიდევ ერთი კომპლექტი სინონიმები
რომ თქვენ შეიძლება ექმნებათ.
ეს ფუნქცია ან გამომავალი ჭეშმარიტი ან მცდარი
დამოკიდებულია თუ არა ის სამი lengths შეუძლია მიღების სამკუთხედის.
გახსოვთ მონაცემთა ტიპის, რომ ჩვენ გამოიყენება მიუთითებს ჭეშმარიტი ან მცდარი?
როგორ უნდა გავაკეთოთ განახორციელოს ეს?
კარგად ვიცი, რომ არსებობს რამდენიმე წესები დაკავშირებით სამკუთხედები
რომ რეალურად სასარგებლო იცოდეს.
სამკუთხედი შეიძლება მხოლოდ მხარეებმა დადებითი სიგრძე.
ეს აზრი.
თქვენ ალბათ ამბობდა, duh.
სხვა რამ აღვნიშნო თუმცა, ის არის, რომ თანხა
საქართველოს lengths ნებისმიერი ორ მხარეს სამკუთხედის
მეტი უნდა იყოს, ვიდრე ხანგრძლივობა მესამე მხარეს.
ეს არის ის სინამდვილეში.
თქვენ არ გაქვთ სამკუთხედის მხარეს 1, 2 და 4, მაგალითად, იმის გამო, რომ 1 + 2
არ აღემატება 4.
ასე რომ, ეს არის წესები, რომ განსაზღვრავს თუ არა სამი
საშუალებებით ძალუძს ქმნიან სამკუთხედის.
ასე რომ მიიღოს რამდენიმე წუთში და აცხადებენ, და შემდეგ განსაზღვრავს
ამ ფუნქციის მოუწოდა მოქმედებს სამკუთხედი, ისეთი, რომ ეს რეალურად
აქვს ქცევის მითითებული აქ.
>> არადა ნამდვილი თუ იმ სამ მხარეს შეუძლია მოიცავს სამკუთხედის,
და ცრუ სხვაგვარად მზად იმისათვის, რომ ნახოთ, თუ როგორ გააკეთა?
აი ერთი განხორციელება მოქმედი სამკუთხედის.
ეს არ არის მხოლოდ ერთი.
Yours შეიძლება განსხვავდებოდეს ოდნავ.
მაგრამ ეს ერთი აკეთებს, სინამდვილეში, ქცევა, რომელიც ჩვენ ველით.
ჩვენ ვაცხადებთ ჩვენი ფუნქცია ზე ძალიან ზევით, bool მოქმედებს სამკუთხედის
float x float y float z.
ასე რომ კიდევ ერთხელ, ამ ფუნქციის სამ რეალური ციფრები
როგორც მისი არგუმენტები, მცურავი წერტილი ღირებულება ცვლადები,
და შედეგები ჭეშმარიტი ან მცდარი ღირებულება, რომელიც არის ლოგიკური, გაწვევას.
ასე რომ, რატომ დაბრუნების ტიპის bool.
მაშინ ჩვენ განვსაზღვროთ ფუნქცია.
პირველი, რასაც ვაკეთებთ არის შეამოწმებს დარწმუნდით რომ ყველა მხარე დადებითი.
თუ x ნაკლებია ან ტოლი 0, ან თუ y უდრის 0,
ან თუ z ნაკლებია ან ტოლი 0, რომ არ შეიძლება იყოს სამკუთხედის.
მათ არ აქვთ დადებითი მხარეები.
ასე რომ, ჩვენ შეიძლება დაბრუნდეს ცრუ, რომ სიტუაცია.
შემდეგი, ჩვენ შეამოწმოს დავრწმუნდეთ, რომ ყველა წყვილი საშუალებებით
უფრო მეტია, ვიდრე მესამე.
>> ასე რომ, თუ x + y ნაკლებია მეტი ან ტოლია z,
ან თუ x + z ნაკლებია მეტი ან ტოლია y,
ან თუ y + z ნაკლებია ან ტოლი x, რომელიც ასევე არ შეიძლება იყოს მოქმედი სამკუთხედის.
ასე რომ, ჩვენ დაბრუნების ცრუ ერთხელ.
თუ დავუშვებთ, ჩვენ გავიდა ორივე ამოწმებს თუმცა, მაშინ ჩვენ შეგვიძლია დაბრუნდება ნამდვილი.
იმის გამო, რომ ამ სამ მხარეს შეუძლია returning--
შექმნის მოქმედებს სამკუთხედის.
და ეს არის ის.
შენ ახლა განაცხადა და განისაზღვრება.
და თქვენ შეუძლია ახლა გამოყენება და დარეკეთ ამ ფუნქციას.
ყოჩაღ.
მე Doug Lloyd.
ეს არის CS50.