[Powered by Google Translate] Нека поговорим за structs.
Structs ни предоставяте с начина, по който да се групират заедно куп променливи
в хубава опаковка.
Това е може би най-лесно да видите пример веднага,
затова ние казваме структура,
след това отваряне на фигурна скоба,
и в тази структура, ще имаме INT възраст,
знак име *
и това е всичко.
Тя може да изглежда странно с точка и запетая след презрамки къдрава
но това е в действителност е необходимо, с structs.
Всеки валиден тип могат да отидат в рамките на дефиницията на структурата.
Тук сме използвали вътр и Чар *
но бихте могли да използвате масив, казват, 100 елемента
или дори друг структура.
Когато използвате structs в C,
създаването на нови видове
от колекция на други видове.
Ето, ние правим нов тип
от цяло число и Чар *.
Както ще видим по-късно, структура тип
е в много начини, еквивалентни на всеки друг вид, с което сте свикнали.
Обикновено, аз ще се сравнява как една структура тип
е подобен на целочислен тип.
Докато код писахме е валидна C,
това не е много полезно,
И звъня ще ни даде предупреждение.
Спомняш ли си как structs и са сходни?
Е, ние просто каза
ПНА,
, което не е много полезно линия.
Така че нека да декларираме променлива от този тип
, като му дава име преди точка и запетая.
Ще се обадя на променлива студент.
Сега сме обявен за променлива нар. студентски
с типа, дадено от структурата.
Как да стигнем до променливите вътре в структурата?
Технически, имената на тези променливи
са членове.
За достъп до всеки отделен потребител в студентско структура,
добавете точка към името на променливата,
последвано от името на члена, който искате.
Така че тук, само две валидни възможности
са student.age
student.name.
И ние можем да направим нещо подобно
student.age = 12
и student.name = ученик.
Сега какво, ако ние искахме да направим втори ученик?
Може би си мислите да копирате и поставяте тези линии
и променете студент студент 2 или нещо,
и че ще работи,
но технически, студент и ученик 2
не са от същия тип.
Вижте, вие няма да можете да ги зададете един към друг.
Това е така, защото, доколкото,
структура е анонимно.
Ние трябва да му се даде име.
За да направите това, въведете името на структурата
след думата структура.
студент,
последвано от това определение.
Все още можем да незабавно да обяви една променлива от тип
структура студент, както направихме преди.
Ще го наречем S1
Давайки структура име,
вече могат да използват студент структура
в почти точно по същия начин щяхме да използваме вътр.
Така че ние може да декларира променлива от тип структура студент,
като
структура на студент S2.
Подобно на масиви, structs синтаксис комбинация инициализация,
така че можем да кажем, структура студент S2
се равнява на
лявата фигурна скоба 3, S2.
Тук S2.age ще бъде 3,
и S2.name ще посочи S2.
Помислете за всички неща, които можете да направите с INT тип
и повечето от тях можете да правите с тип структура студент.
Ние можем да използваме студент структура като тип параметър на функция.
Ние можем да използваме студент структура в рамките на нова структура.
Ние можем да имаме указател към структура студент.
Ние можем да направим размера на структурата студент.
Структура на студент е вид
точно като число е тип.
Може също да присвоите S1 до S2
, тъй като и двете са от същия тип, така че можем да направим
S1 = S2.
Какво ще се случи, ако ние не направим
S1.age = 10?
Ли S2 промяна на всички?
Отново, мисля на structs като редовни числа.
Ако зададете някои INT X до известна Int Y,
като X = Y
и след това да промените X,
като в X + +,
Y промени на всички?
Y не се променя, и така и не S2-горе.
S2.age все още е 3.
Но имайте предвид, че при възлагането на една структура в друга,
всички указатели все още сочат към едно и също нещо,
тъй като те са просто копират.
Ако не искате указатели, които да бъдат споделени,
ще трябва ръчно да се справиш с това,
може би от malicking един блок от памет за един от указатели да сочи към
и копиране на данни.
То може да бъде досадно да трябва да напишете студент структура навсякъде.
Използването на Def, можем да направим
тип дефиниция
структура
и ние ще го наричат ​​студент.
Сега, ние можем да използваме студент навсякъде
че сме свикнали да използват студент структура.
Този тип Def анонимен структура
и го нарича студент.
Но ако ние също студент идентификатор
до думата структура, тъй като в typedef структурата на студент,
бихме могли да използваме структура студент и ученик взаимозаменяеми.
Те дори не трябва да имат едно и също име.
Бихме могли да въведете Def студент структура на Боб
и след това структурата на студентите и Боб
са взаимозаменяеми видове.
Независимо от вида Def,
ние се нуждаем от идентификатор до структура
ако определението на структурата на
е рекурсивен.
Например,
тип дефиниция структура възел
и ще бъдат определени като INT Вал
и ще има указател, който сочи към друга структура възел.
както в структурата възел * следващия.
И тогава ние ще го наричаме възел.
Тази структура е рекурсивен,
, тъй като определянето на структурата възел съдържа в себе си
указател към структура възел.
Забележете, че ние трябва да кажа, структура възел * следващия
в рамките на определението на структурата на възел,
от вида Def все още не е приключил за да ни позволи да се опрости тази
просто възел *.
Ще научите повече за structs подобни на тази
когато става дума за свързани списъци и дървета.
Ами structs във функция?
Това също е напълно валиден.
Ние може да има
анулира функции
, която приема като аргумент,
Студентски
и прави нещо с този студент.
И тогава можем да го мине като студент структура като толкова.
Func на S1 от преди.
Структура се държи
точно като цяло число, когато се подава на функцията.
Func получава копие от S1
и затова не могат да променят S1;
, а само копие от нея, която се съхранява в S.
Ако искате функция, за да бъде в състояние да променят S1,
функция ще трябва да си взема студент * S,
и ще трябва да преминат S1 по адрес, като така.
Студентски * S, функции и S1.
Има още една причина да премине по адрес тук.
Какво става, ако нашата структура, съдържаща 100 полета?
Всеки път, минаваме студент да функционира,
нашата програма трябва да копирате всички от тези 100 полета в аргумент S функции,
дори ако никога не го използва по-голямата част от тях.
Така че, дори ако функцията не планира промяна на студент,
ако все още може да бъде полезно да премине по адрес.
Добре, какво ще стане, ако искаме да създадем указател на структура?
Бихме могли да направим нещо подобно
студент * S
се равнява на изчистване
размер на студента.
Забележете, че размера на все още работи тук.
И така, как ние сега достъп до Години
на блока, че S точки, за да?
Може би първо мисля да направя
* S.age = 4,
но това няма да работи.
Тъй като това наистина ще се тълкува като
* S.age в скоби = 4,
, които дори няма да съставят,
тъй като S не е структура, или по-скоро показалеца на структурата,
и така точката няма да работи тук.
Можем да го направим
(* S). Възраст = 4
но скобите може да получи досадно и объркващо.
За щастие, ние имаме специален оператор стрелка
, който изглежда нещо като
S-> възраст = 4.
Тези два начина на съотнасяне на възраст
са еквивалентни
и ние не наистина някога се нуждаят от оператора стрелка,
но това прави нещата изглежда по-добре.
Тъй като S е показалеца на някои блок на паметта, която съдържа структура,
можеш да се сетиш S> възраст, както следва стрелката показалец
и вземете потребител възраст.
Така че защо трябва ние някога използват structs?
Това определено е възможно да се размине само с примитивни числа,
символа, препратки и други подобни
че сме свикнали;
вместо S1 и S2 преди,
бихме могли да са имали age1, age2, NAME1 и NAME2
на отделни променливи.
Това е добре, само с 2 студенти,
но какво ще стане, ако имахме 10 от тях?
И какво ще стане, ако вместо само два полета,
структура на студента имаше 100 полета?
GPA, курсове, цвят на косата, пол, и така нататък.
Вместо само на 10 structs, ние се нуждаем 1000 отделни променливи.
Също така, помислете функция
че тази структура с 100 полета само с аргумент
и отпечатва всички полета.
Ако ние не се използва структура,
всеки един момент ние наричаме тази функция,
ние трябва да мине на всички 100 променливи,
и ако имаме 100 променливи за студент 1,
и 100 променливи за студент 2,
ние трябва да сме сигурни, че не случайно минават някои променливи от студентски 1
и някои променливи от студент 2.
Това е невъзможно да се направи тази грешка с структура,
тъй като всички 100 променливи се съдържат в един пакет.
Само няколко на крайните бележки:
Ако сте разбрали всичко, което до този момент, страхотно.
Останалата част от видеото е само за изчерпателност ".
Тъй като structs може да побере всякакъв вид на показалеца,
те могат също така да провеждат функция указатели.
Ако сте запознати с обектно-ориентирано програмиране,
това осигурява начин за използване на structs програма в обектно-ориентиран стил.
На функцията указатели по друго време.
Също така, понякога може да се наложи 2 structs
, чиито дефиниции зависят един от друг.
Например,
бихме могли да имаме структура на A,
която се определя като
указател към структурата Б,
структура B * X,
и сега можем да имаме Б структура
която се определя като показалка
структура на A,
структура на A * Y.
Но това няма да съставят,
тъй като структура Б не съществува в момента, че структурата се съставя.
И ако ние суап структура А и структура B,
то ние просто щяхме да останат с един и същ проблем;
този път, със структура не съществува.
За да се разреши този проблем, ние можем да напишем
структура Б;
преди определянето на структурата на А.
Това се нарича напред декларация.
Това позволява на компилатора да знаете, че
структура B е валиден тип, който ще бъде напълно дефиниран по-късно или на друго място.
Моето име е Роб Боудън, и това е CS50.
[CS50.TV]