[Powered by Google Translate] Ајде да зборуваме за structs.
Structs ни овозможи со еден начин да ги групирате еден куп на променливи заедно
во еден убав пакет.
Тоа е веројатно најлесниот да видите пример веднаш,
па велиме struct,
потоа отворање кадрава голема заграда,
и во овој struct, ќе имаат int возраст,
на char * име,
и тоа е тоа.
Тоа може да изгледа чудно со точка-запирка после подготвуваат кадрава,
но тоа е всушност потребно со structs.
Некој валиден тип може да оди во структурата дефиниција.
Еве, ние сме користеле int и char *,
но вие исто така може да се користи низа, на да речеме, 100 елементи
или дури и друга struct.
Кога сте со користење structs во C,
сте создавање нови видови
од колекцијата на другите видови.
Тука, ние се прави нов тип
од цел број и char *.
Како што ќе видиме подоцна, struct тип
е во многу начини еквивалентно на било кој друг вид сте навикнати.
Обично, ќе се споредуваат како struct тип
Слична е цел број тип.
Додека го кодот ние напиша важи Ц,
тоа не е многу корисно,
и ѕвекот ќе ни даде предупредување.
Се сеќавам како structs и се слични?
Па, ние во основа, само рече
int,
што не е многу корисна линија.
Па ајде всушност декларирате променлива од тој вид
од страна давајќи му име пред запирка.
Ние ќе се јавите на променлива студент.
Сега сме прогласи променлива наречена студент
со типот дадена од страна на struct.
Како да ја добиете на променливи внатре во структурата?
Технички, имиња за овие променливи
се членови.
Да пристапите на некој особено член во студентски struct,
ќе додадете точка на името на променливата,
проследено со името на земјите сакате.
Значи тука, само 2 валидна можности
се student.age
и student.name.
И можеме да направиме нешто како
student.age = 12
и student.name = студент.
Сега што ако сакаме да се направи втор студент?
Можеби мислите да копирате и залепите овие линии
и промена студент до студент 2 или нешто,
и дека ќе работи,
но технички, ученик и студент 2
немаат ист тип.
Види, нема да бидете во можност да им доделите еден на друг.
Тоа е затоа што, досега,
вашиот структурата е анонимен.
Ние треба да го даде името.
За да го направите тоа, ние внесете го името на struct
по зборот struct.
студент,
проследено со дефиницијата.
Ние се уште може веднаш да декларирате променлива од тип
struct студент, како што беше порано.
Ние ќе го наречеме S1
Со давање на struct име,
ние сега може да користи struct студент
во скоро исти начин би го користите int.
Значи можеме да декларирате променлива од тип struct студент,
како
struct студент S2.
Како низи, structs обезбеди кратенка иницијализација синтакса,
па може да се каже, struct студент S2
еднакво
левата кадрава голема заграда 3, S2.
Еве, S2.age ќе биде 3,
и S2.name ќе точка за S2.
Помислете на сите работи што можете да направите со int тип
и повеќето од нив може да се направи со struct студент тип.
Може да се користат struct студент, како еден вид на функција параметар.
Можеме да го користиме struct студент во внатрешноста на новиот struct.
Ние може да има покажувач на struct студент.
Ние можеме да правиме големината на struct студент.
Struct студент е еден вид
исто како int е тип.
Ние, исто така може да додели S1 да S2
бидејќи и двете се од ист тип, така што можеме да направиме
S1 = S2.
Што се случува ако правиме
S1.age = 10?
Дали S2 промена на сите?
Повторно, мислам на structs само како редовни броеви.
Ако ние доделите некој int x некои int y,
како X = Y
и потоа да се промени X,
во X + +,
не Y промена на сите?
Y не се менува тука, па ниту пак S2 погоре.
S2.age се уште е 3.
Но, имајте во предвид дека при доделување на една struct на друг,
сите покажувачи уште укажуваат на истото,
бидејќи тие беа само копирани.
Ако не сакате совети како да се дели,
ќе треба рачно да се справи со тоа,
можеби со malicking еден блок од меморија за еден од совети како да се укаже на
и копирање на податоци преку.
Тоа може да биде досадно да мора да пишува struct студент насекаде.
Помош на еден вид дефиниција, можеме да направиме
тип дефиниција
struct
и ние ќе го наречеме студент.
Сега, можеме да го користиме студент секаде
дека ние се користи за употреба struct студент.
Овој тип дефиниција е анонимен struct
и тоа го нарекува студент.
Но ако ние, исто така, имајте на студентот идентификатор
до збор struct, како и во typedef struct студент,
можеме да го користите двете struct ученик и студент мешаат сега.
Тие дури и не мора да имаат исто име.
Ние би можеле да напишеш дефиниција struct студент на Боб
а потоа struct студент и Боб
ќе биде заменлив типови.
Без оглед на видот дефиниција,
ние треба идентификатор до struct
ако дефиницијата на struct
е рекурзивен.
На пример,
тип дефиниција struct јазол
и тоа ќе се дефинира како int val
и тоа ќе има покажувач кој покажува кон друга struct јазол.,
како и во структурата јазол * следната.
А потоа ние ќе го нарекуваат јазол.
Ова struct е рекурзивен,
Од дефиницијата на struct јазол содржи во неа
покажувач на struct јазол.
Забележете дека ние треба да се каже struct јазол * следниот
внатрешноста на дефиницијата на struct јазол,
од типот дефиниција не е завршена уште да ни овозможи да се поедностави оваа
само јазол * следната.
Ќе дознаете повеќе за structs слични на овој
кога се занимаваат со поврзани листи и дрвја.
Што structs во функција?
Ова е исто така совршено валидни.
Ние би можеле да имаат
поништат функции
кој ги зема како аргумент,
студент на
и не нешто со што студентот.
И потоа можеме да го помине како студент struct како тоа.
Функции на S1 од порано.
На struct однесува
токму како цел број би, кога помина на функцијата.
Функции добива копија од S1
и затоа не може да го менува S1;
Наместо тоа, само копија од тоа дека е се чуваат во С
Ако сакате функцијата да биде во можност да менувате S1,
функции ќе треба да се земе студентот * S,
и ќе треба да помине S1 по адреса, како и толку.
Студентски * S, функции и S1.
Има уште една причина да помине адреса тука.
Што ако нашите struct содржани 100 полиња?
Секој пат кога ќе преминеме на студентите да функцио,
нашата програма треба да го копирате сите оние 100 полиња во аргумент S функции е,
дури и ако никогаш не го користи огромното мнозинство од нив.
Па дури и ако функцијата не планирате за менување на студентот,
ако сеуште може да бидат корисни да помине адреса.
Океј, што ако сакаме да се создаде покажувач на struct?
Можеме да направиме нешто како
Студентот * S
еднакво Примерок
големината на студентот.
Забележете дека големината на уште работи тука.
Така како ние сега пристапите на возраст член
на блок кој S поени?
Прво ќе мислам да се направи
* S.age = 4,
но ова не е сосема ќе работат.
Бидејќи ова навистина ќе се толкува како
* S.age во загради = 4,
кои дури и не ќе ги собере,
бидејќи s не е struct или подобро покажувач кон struct,
и така точка не ќе работат тука.
Ние може да направи
(* С). Возраст = 4
но загради може да се досадни и збунувачки.
За среќа, имаме посебна arrow оператор
што изгледа нешто како
S-> возраст = 4.
Овие 2 начини на референцирање возраст
се еквивалентни
и ние навистина не некогаш треба стрелките на операторот,
но тоа го прави работите изгледаат поубаво.
Од S е покажувач кон некои блок од меморија, која содржи struct,
можете да замислите С> возраст како што следи покажувачот стрелка
и го имате на возраст член.
Па зошто треба ние никогаш не се користи structs?
Тоа е дефинитивно возможно да се извлечат само со примитивни цели броеви,
знаци, совети и слично
дека ние сме навикнати;
наместо S1 и S2 пред,
ние би можеле да имаат age1, age2, name1 и name2
сите во одделни променливи.
Ова е во ред со само 2 ученици,
но што ако имавме 10 од нив?
А што ако, наместо на само 2 полиња,
студентот struct имаше 100 полиња?
Успех, курсеви, коса боја, пол, и така натаму.
Наместо само 10 structs, ние треба 1.000 одделни променливи.
Исто така, сметаат функција
кој ги зема дека struct со 100 полиња со единствен аргумент
и отпечатоци од сите области.
Ако ние не се користи структурата,
секој пат кога ние го нарекуваме таа функција,
ние треба да го поминат на сите 100 променливи,
и ако имаме 100 променливи за студентски 1,
и 100 променливи за студентски 2,
ние треба да бидете сигурни дека ние не случајно поминуваат некои променливи од ученик 1
а некои променливи од студент 2.
Тоа е невозможно да се направи таа грешка со структурата,
бидејќи сите 100 променливи се содржани во едно пакување.
Само неколку конечниот белешки:
Ако сте се разбере што до овој момент, одлично.
Остатокот на видео е само заради комплетност.
Бидејќи structs може да се одржи било кој тип на покажувач,
тие исто така може да се одржи функција покажувачи.
Ако сте запознаени со објектно ориентирано програмирање,
ова обезбедува начин да се користи structs да програма во објектно ориентирано стил.
Повеќе за функција покажувачи на некое друго време.
Исто така, понекогаш може да имате 2 structs
чии дефиниции зависат еден од друг.
На пример,
ние би можеле да имаат struct А,
кој е дефиниран како
покажувач на struct Б,
struct Б * X,
и сега може да имаме struct Б
кој е дефиниран како покажувач
на struct А,
struct А * Ј
Но, тоа не ќе состави,
од struct Б не постои во тоа време дека struct А се составени.
И ако ние трампа struct А и структурата Б,
тогаш ние само ќе си бидат оставени со истиот проблем;
овој пат, со struct А не постои.
За да се реши ова, ние може да напише
struct Б;
пред дефинирањето на struct А
Ова се нарекува напред декларација.
Ова само им овозможува на компајлерот знае дека
struct Б е валиден тип кој ќе биде целосно дефинирана подоцна или на друго место.
Моето име е Роб Бауден, и ова е CS50.
[CS50.TV]