[Powered by Google Translate] Хајде да причамо о Структуре.
Структуре нам обезбеди начин да заједно ГРУПА гомилу променљивих
у лепом паковању.
Вероватно је најлакше да видите пример одмах,
тако кажемо струцт,
затим отварање коврџаву браће,
и у овом струцт ћемо имати инт старост,
цхар * име,
и то је то.
То може да изгледа чудно са зарезом после коврџаве браце,
али то је у ствари потребно за Структуре.
Сваки важећи типа могу да иду у струцт дефиниције.
Овде смо користили инт и цхар *,
али такође може да користи низ, од рецимо, 100 елемената
или чак други струцт.
Када користите Структуре у Ц,
правите нове типове
из колекције других типова.
Ево, ми правимо нови тип
од целог броја и цхар *.
Као што ћемо видети касније, струцт тип
је у много начина еквивалентне неком другом типу сте навикли.
Обично, ја ћу бити у односу како је струцт тип
је слична целобројни тип.
Док код нас написао важи Ц,
није веома корисно,
и јека ће нам дати упозорење.
Сетите се како Структуре и њени су слични?
Па, ми смо само у основи рекли
инт
што није од велике помоћи линија.
Дакле, хајде да ствари прогласи променљиву тог типа
дајући му име пре зарезом.
Ми ћемо позвати променљиве студента.
Сада смо прогласила променљиву зове студента
са типом дате од стране струцт.
Како ћемо доћи до променљивих унутар струцт?
Технички, имена за ове променљиве
нису чланови.
Да бисте приступили неки посебан члан у студентском струцт,
да додате тачку на име променљиве,
следи име члана желите.
Дакле, овде, само 2 важећи могућности
су студент.аге
и студент.наме.
И можемо да урадимо нешто слично
студент.аге = 12
и студент.наме = ученик.
Сада шта ако бисмо желели да направимо другу студента?
Можда мислите да копирате и налепите ове линије
и промените студенту студенту 2 или тако нешто,
и да ће радити,
али технички, студент и ученик 2
немају исти тип.
Видите, ви нећете бити у могућности да их доделите једни другима.
То је зато што, до сада,
Ваш струцт је анониман.
Морамо му дати име.
Да бисте то урадили, ми убаците име струцт
после речи струцт.
студент,
следе дефиницији.
Ми још увек можемо одмах да прогласи променљиву типа
струцт студент, као што смо урадили раније.
Ми ћемо позвати га С1
Дајући струцт име,
сада можемо да користимо студента струцт
у скоро потпуно исти начин на који ће користити инт.
Дакле, можемо да прогласи променљиву типа струцт студента,
као
струцт студент С2.
Као низовима, Структуре обезбеђују пречице иницијализацију синтаксу,
тако да можемо рећи, струцт студент С2
једнак
лева коврџава браће 3, С2.
Овде С2.аге ће бити 3,
и С2.наме ће указати на С2.
Размислите о свим стварима које можете да урадите са инт типа
и већина њих можете да урадите са типом струцт студент.
Можемо користити студента струцт као вид функцијским параметра.
Можемо користити студентима струцт унутар новог струцт.
Можемо имати показивач на структуру струцт студента.
Можемо да урадимо величину струцт студента.
Струцт студент је тип
баш као инт је тип.
Ми такође можемо доделити С1 С2 да
пошто су оба од истог типа, тако да можемо да урадимо
С1 = С2.
Шта се дешава ако урадимо
С1.аге = 10?
Да ли С2 промене уопште?
Опет, мислим да је од Структуре као редовне целих бројева.
Ако смо доделили неки инт неком инт,
као Кс = И
а затим промените Кс,
као у Кс + +,
не И промени уопште?
И не мења овде, па ни не С2 горе.
С2.аге је још 3.
Али имајте на уму да, када додељивања једног струцт на други,
сви показивачи и даље указују на исту ствар,
јер су само копирају.
Ако не желите да се показивачи да се дели,
ћете морати да ручно средим,
можда малицкинг један блок меморије за једног од показивача да укаже на
и копирање података преко.
Било би досадно да се свуда пише студента струцт.
Користећи типа деф, можемо да урадимо
Тип деф
струцт
и ми ћемо га зову ученик.
Сада можемо да користимо студента свуда
да смо користили студента струцт.
Овај тип деф је анонимни струцт
и назива га ученик.
Али ако ми такође задржати идентификатор студента
поред речи струцт, као типедеф струцт студент,
можемо користити и студент и ученик струцт наизменично сада.
Они чак не морају да имају исто име.
Могли упишите деф струцт студент Бобану
и онда струцт студент и Боба
би изменљиве врсте.
Без обзира на тип деф,
морамо идентификатор поред струцт
ако је дефиниција струцт
је рекурзивни.
На пример,
Тип деф струцт ноде
и она ће бити дефинисан као инт вал
и она ће имати показивач који указује на другу струцт чвора.,
као у струцт ноде * следећи.
А онда ћемо га зову чвор.
Ово струцт је рекурзивна,
јер дефиниција струцт ноде садржи у себи
показивач на структуру струцт чвор.
Приметимо да морамо да кажемо струцт ноде * следећу
унутар дефиниције струцт чвора,
Од типа деф није завршио тек треба да нам омогућавају да поједноставе ово
на само чвор * следећи.
Сазнаћете више о Структуре као ово
када се ради о повезаним листама и дрвећа.
Шта Структуре у функцији?
Ово је такође савршено валидан.
Могли смо
воид фунц
који узима као аргумент,
Студент а
и уради нешто са том ученику.
И онда можемо проћи као студент струцт овако.
Фунц од С1 од раније.
Струцт понаша
тачно онако како би цео када прослеђује функцији.
Фунц добија копију С1
па не може да измени С1;
већ само копија томе да се чувају у С.
Ако желите да функција да буде у стању да модификује С1,
фунц ће морати да се * студент С,
а ви ћете морати да прође С1 по адреси, овако.
Студент * С, функ & С1.
Постоји још један разлог да прође адресу овде.
Шта ако је наша струцт садржао 100 поља?
Сваки пут кад прође студента да функцио,
наш програм треба да копирате све те области у 100 аргумената С ФУНЦ а,
чак и ако се не користи огромну већину њих.
Дакле, чак и ако функција не планирам модификовања студента,
Ако још увек може бити драгоцено да прође адресу.
Ок, шта ако желимо да створимо показивач на структуру?
Могли би тако нешто
Студент * С
једнако маллоц
величина студента.
Приметите да обим и даље ради овде.
Па како ћемо приступити члана старосну
блока који указује на С?
Морате прво помислити да урадите
* С.аге = 4,
али то неће баш радити.
Пошто ће ово заиста бити протумачено као
* С.аге у загради = 4,
које неће ни саставити,
С обзиром није струцт односно показивач на структуру,
па тачка неће радити овде.
Могли урадити
(* С). Старост = 4
али заграде могу добити досадне и збуњујуће.
Срећом, имамо посебну стрелицом оператера
који изгледа нешто као
С-> године = 4.
Ове 2 начина обележавања године
су еквивалентни
а ми стварно не треба никада оператера стрелице,
али чини ствари изгледају лепше.
Пошто је С показивач на неки блок меморије који садржи струцт,
можете мислити с> доба као пратите стрелицу показивача
и зграби члана старости.
Па зашто би смо икада користили Структуре?
Дефинитивно је могуће извући само са примитивним целих бројева,
слова, показивачи и слично
да смо навикли;
уместо С1 и С2 пре,
могли смо имали аге1, аге2, НАМЕ1 и НАМЕ2
све на одвојеним променљивих.
То је у реду са само 2 ученика,
али шта ако смо имали 10 од њих?
А шта ако уместо само 2 поља,
Студент струцт имала 100 поља?
ГПА, курсеви, коса боје, пола, и тако даље.
Уместо само 10 Структуре, морамо 1.000 одвојене променљиве.
Такође, размислите функцију
који узима тај струцт са 100 поља са својим једини аргумент
и исписује сва поља.
Ако нисмо користили струцт,
сваки пут кад зовем те функције,
морамо проћи на свим 100 варијабли,
и ако имамо 100 променљивих за студента 1,
и 100 варијабле за студента 2,
морамо да будемо сигурни да се не случајно пролазе неке променљиве из студента 1
и неке променљиве из студента 2.
То је немогуће направити такву грешку са струцт,
јер су сви 100 променљиве се налазе у једном пакету.
Само пар завршних нота:
Ако сте разумели све до ове тачке, велико.
Остатак видео је само ради комплетности '.
Зато Структуре могу имати било коју врсту показивача,
они такође могу да имају показиваче функција.
Ако сте упознати са објектно оријентисаног програмирања,
ово обезбеђује начин да користи Структуре програму у објектно оријентисане стилу.
Више о функција показивача у неко друго време.
Такође, понекад можете имати 2 Структуре
чије дефиниције зависе један од другог.
На пример,
могли смо струцт,
која је дефинисана као
показивач на структуру струцт Б,
струцт Б * Кс
и сада можемо да имамо Б струцт
који је дефинисан као показивач
да струцт,
струцт * И.
Али то неће саставити,
јер струцт Б не постоји у тренутку када струцт се саставио.
А ако смо заменили струцт и струцт Б
онда бих само да остане са истим проблемом;
овај пут, са струцт не постоји.
Да бисте решили ово, можемо да пишемо
струцт Б;
пре дефинисања струцт А.
Ово се зове напред декларацију.
То само омогућава компајлер зна да
струцт Б је важећи тип који ће у потпуности бити дефинисани касније или негде другде.
Моје име је Роб Бовден, а ово је ЦС50.
[ЦС50.ТВ]