[Powered by Google Translate] ચાલો સ્ટ્ર્ક્ટ્સ વિશે વાત કરો.
સ્ટ્ર્ક્ટ્સ અમને માટે ચલો સમૂહ સાથે મળીને જૂથ રસ્તો પૂરો પાડે છે
એક સરસ પેકેજ માં.
તે કદાચ સૌથી સરળ ઉદાહરણ અધિકાર દૂર જુઓ,
તેથી, અમે કહીએ છીએ સ્ટ્રક્ટ,
પછી સર્પાકાર તાણવું ખોલીને,
અને આ સ્ટ્રક્ટ માં, અમે પૂર્ણાંક વય પડશે,
ચાર રચે છે * નામ,
અને તે છે.
તે અર્ધવિરામ સાથે વિચિત્ર એક સર્પાકાર તાણવું પછી લાગે,
પરંતુ તે સ્ટ્ર્ક્ટ્સ સાથે જરૂરી હકીકતમાં છે.
કોઈપણ માન્ય પ્રકાર સ્ટ્રક્ટ વ્યાખ્યા અંદર જઈ શકો છો.
અહીં, અમે પૂર્ણાંક અને કોલસો બનાવો * ઉપયોગ કર્યો છે,
પરંતુ તમે પણ એરે ઉપયોગ કરી શકે કહે છે, 100 તત્વો
અથવા તો અન્ય સ્ટ્રક્ટ.
જ્યારે તમે સી સ્ટ્ર્ક્ટ્સ ઉપયોગ કરી રહ્યા છો,
તમે નવા પ્રકારની બનાવી રહ્યાં છો
બહાર અન્ય પ્રકારના એક સંગ્રહ છે.
અહીં, અમે એક નવા પ્રકારની કરી રહ્યા છીએ
એક પૂર્ણાંક અને કોલસો બનાવો * ના.
આપણે પાછળથી જોશો, એક સ્ટ્રક્ટ પ્રકાર
બીજા કોઈપણ પ્રકારની તમે ઉપયોગ કરી રહ્યાં છો સમકક્ષ ઘણી બધી રીતે છે.
સામાન્ય રીતે, હું સ્ટ્રક્ટ કેવી રીતે પ્રકાર તુલના કરવામાં આવશે
પૂર્ણાંક પ્રકાર જેવી જ છે.
જ્યારે કોડ અમે લખ્યું માન્ય સી છે,
તે ખૂબ જ ઉપયોગી નથી,
અને રણકાર અમને ચેતવણી આપશે.
યાદ રાખો કે કેવી રીતે સ્ટ્ર્ક્ટ્સ અને તેના જેવા જ હોય ​​છે?
વેલ, અમે મૂળભૂત રીતે ફક્ત જણાવ્યું
પૂર્ણાંક,
જે ખૂબ જ મદદરૂપ રેખા નથી.
તેથી આપણે ખરેખર તે પ્રકારના એક ચલ જાહેર
તે અર્ધવિરામ પહેલાં એક નામ આપીને.
અમે ચલ વિદ્યાર્થી કૉલ કરશો.
હવે અમે એક ચલ કહેવાતા વિદ્યાર્થી જાહેર કર્યું છે
આ સ્ટ્રક્ટ દ્વારા આપવામાં પ્રકાર છે.
અમે સ્ટ્રક્ટ અંદર ચલો સાથે કેવી રીતે મેળવી શકું?
પારિભાષિક રીતે, આ ચલો માટે નામો
સભ્યો છે.
એક વિદ્યાર્થી સ્ટ્રક્ટ કોઈપણ ચોક્કસ સભ્ય ઍક્સેસ કરવા માટે,
તમે પરિવર્તનશીલ નામ પર કોઈ ઉમેરી,
સભ્ય તમે કરવા માંગો છો તે નામ છે.
તેથી અહીં, માત્ર 2 માન્ય શક્યતાઓ
student.age છે
અને student.name.
અને અમે કંઈક જેવા કરી શકો છો
student.age = 12
અને student.name = વિદ્યાર્થી.
હવે જો આપણે બીજા વિદ્યાર્થી માગતા હતા?
તમે નકલ અને આ રેખાઓ પેસ્ટ લાગે શકે છે
અને 2 વિદ્યાર્થી અથવા કંઈક કરવા માટે વિદ્યાર્થી બદલવા માટે,
અને તે કામ કરશે,
પરંતુ ટેકનિકલી વિદ્યાર્થી અને 2 વિદ્યાર્થી
તે જ પ્રકારનું હોય છે.
જુઓ, તો તમે તેમને એક બીજા સોંપી શકશો નહીં.
આ કારણ કે, અત્યાર સુધી છે,
તમારા સ્ટ્રક્ટ અનામિક રહી છે.
અમે તેને એક નામ આપો જરૂર છે.
કે કરવા માટે, અમે સ્ટ્રક્ટ નું નામ દાખલ કરો
શબ્દ સ્ટ્રક્ટ પછી.
વિદ્યાર્થી,
વ્યાખ્યા છે.
અમે હજુ પણ તરત જ પ્રકારની એક ચલ જાહેર કરી શકો છો
વિદ્યાર્થી સ્ટ્રક્ટ, જેમ કે અમારી પહેલાં હતી.
અમે તેના એસ 1 કૉલ પડશે
આ સ્ટ્રક્ટ એક નામ આપીને,
આપણે હવે સ્ટ્રક્ટ વિદ્યાર્થી ઉપયોગ કરી શકો છો
લગભગ ચોક્કસ જ રીતે અમે પૂર્ણાંક ઉપયોગ કરશે.
તેથી અમે પ્રકાર સ્ટ્રક્ટ વિદ્યાર્થી ચલ જાહેર કરી શકે છે,
સમાન
સ્ટ્રક્ટ વિદ્યાર્થી S2.
એરે જેમ, સ્ટ્ર્ક્ટ્સ એક શૉર્ટકટ આરંભ વાક્યરચના પૂરી પાડે છે,
તેથી, અમે કહીએ છીએ, વિદ્યાર્થી S2 સ્ટ્રક્ટ કરી શકો છો
સમકક્ષ
ડાબી સર્પાકાર 3 તાણવું, S2.
અહીં, S2.age 3 હશે,
અને S2.name S2 માટે નિર્દેશ કરશે.
પૂર્ણાંક પ્રકાર સાથે તમામ વસ્તુઓ તમે કરી શકો છો વિચારો
અને તેમાંના મોટા ભાગના તમે સ્ટ્રક્ટ વિદ્યાર્થી પ્રકાર સાથે કરી શકો છો.
અમે કાર્ય પરિમાણ એક પ્રકાર તરીકે સ્ટ્રક્ટ વિદ્યાર્થી વાપરી શકો છો.
અમે હવે એક નવો સ્ટ્રક્ટ ની અંદર સ્ટ્રક્ટ વિદ્યાર્થી વાપરી શકો છો.
અમે સ્ટ્રક્ટ વિદ્યાર્થી માટે નિર્દેશક હોઈ શકે છે.
અમે સ્ટ્રક્ટ વિદ્યાર્થી કદ કરી શકો છો.
સ્ટ્રક્ટ વિદ્યાર્થી એક પ્રકાર છે
પૂર્ણાંક જેમ જ એક પ્રકાર છે.
અમે પણ S2 માટે S1 સોંપી શકો છો
કારણ કે બંને એક જ પ્રકારનો હોય છે, તેથી અમે શું કરી શકો છો
S1 = S2.
શું થાય જો આપણે શું કરવું
S1.age = 10?
S2 ફેરફાર બધી કરે છે?
ફરીથી, નિયમિત પૂર્ણાંકો તરીકે માત્ર સ્ટ્ર્ક્ટ્સ લાગે છે.
જો અમે કેટલીક પૂર્ણાંક વાય કેટલાક પૂર્ણાંક X સોંપવા માટે,
X = વાય જેમ
અને પછી X બદલવા માટે,
માં X + +,
નથી વાય બધા બદલ્યો?
વાય અહીં બદલી નથી, અને તેથી કોઈ ઉપર S2 કરે છે.
S2.age હજુ 3.
પરંતુ નોંધ જ્યારે અન્ય એક સ્ટ્રક્ટ સોંપણી કે,
આ પોઇંટરો તમામ હજુ પણ એ જ વસ્તુ કરવા માટે નિર્દેશ,
કારણ કે તેઓ ફક્ત નકલ કરવામાં આવી હતી.
જો તમે પોઇંટરો શેર કરવામાં નથી માંગતા,
તમે જાતે કે હેન્ડલ કરવાની જરૂર પડશે,
કદાચ એક પોઇંટરો માટે મેમરી એક બ્લોક malicking દ્વારા નિર્દેશિત કરવા માટે માટે
અને માહિતી નકલ બનાવ્યા.
તે માટે સ્ટ્રક્ટ વિદ્યાર્થી સર્વત્ર લખી છે નકામી હોઈ શકે છે.
એક પ્રકાર ડેફ વાપરીને, અમે શું કરી શકો છો
પ્રકાર ડેફ
સ્ટ્રક્ટ
અને અમે તેને વિદ્યાર્થી કૉલ કરશો.
હવે, અમે વિદ્યાર્થી સર્વત્ર ઉપયોગ કરી શકો છો
કે અમે સ્ટ્રક્ટ વિદ્યાર્થી ઉપયોગ વપરાય છે.
આ પ્રકારની ડેફ એક અનામી સ્ટ્રક્ટ છે
અને તે વિદ્યાર્થી કહે છે.
પરંતુ જો આપણે પણ વિદ્યાર્થી ઓળખકર્તા રાખવા
આગામી શબ્દ સ્ટ્રક્ટ છે, typedef સ્ટ્રક્ટ વિદ્યાર્થી છે,
અમે બંને સ્ટ્રક્ટ વિદ્યાર્થી અને વિદ્યાર્થી એકબીજાના હવે ઉપયોગ કરી શકે છે.
તેઓ પણ આ જ નામ છે નથી.
અમે બોબ ડેફ સ્ટ્રક્ટ વિદ્યાર્થી લખો શકે
અને પછી વિદ્યાર્થી અને બોબ સ્ટ્રક્ટ
વિનિમયક્ષમ પ્રકારના હશે.
અનુલક્ષીને પ્રકાર ડેફ છે,
અમે આગામી ઓળખનારનો સ્ટ્રક્ટ જરૂર
જો સ્ટ્રક્ટ ની વ્યાખ્યા
ફરી યાદ આવવું છે.
ઉદાહરણ તરીકે,
પ્રકાર ડેફ સ્ટ્રક્ટ નોડ
અને તે પૂર્ણાંક Val તરીકે વ્યાખ્યાયિત કરવામાં આવશે
અને તે નિર્દેશક કે અન્ય સ્ટ્રક્ટ નોડ નિર્દેશ હોય છે.,
તરીકે સ્ટ્રક્ટ * આગામી નોડ છે.
અને પછી અમે તેને નોડ કહી શકશો.
આ સ્ટ્રક્ટ ફરી યાદ આવવું છે,
ત્યારથી સ્ટ્રક્ટ નોડ વ્યાખ્યા તેની અંદર સમાવે છે
એક સ્ટ્રક્ટ નોડ માટે નિર્દેશક.
નોંધ કરો કે અમે સ્ટ્રક્ટ નોડ આગામી * કહે છે
અંદર સ્ટ્રક્ટ નોડ વ્યાખ્યા છે,
કારણ કે પ્રકાર ડેફ હજી સમાપ્ત નથી કરવા માટે પરવાનગી આપે છે અમને આ સરળ માટે
માત્ર નોડ * બાજુમાં.
તમે આ માટે સમાન સ્ટ્ર્ક્ટ્સ વિશે વધુ જાણવા મળશે
કડી થયેલ યાદીઓ અને વૃક્ષો સાથે જ્યારે વ્યવહાર.
એક કાર્યમાં સ્ટ્ર્ક્ટ્સ વિશે શું?
આ પણ સંપૂર્ણપણે માન્ય નથી.
અમે કરી શકે છે
func ગેરમાન્ય
જે દલીલ તરીકે લે છે,
વિદ્યાર્થી ઓ
અને તે વિદ્યાર્થી સાથે કંઈક કરે છે.
અને પછી અમે આની જેમ વિદ્યાર્થી સ્ટ્રક્ટ તરીકે તેને પસાર કરી શકે છે.
પહેલાં S1 ઓફ Func.
આ સ્ટ્રક્ટ વર્તે
બરાબર એક પૂર્ણાંક જ્યારે કાર્ય પસાર કરશે.
Func એસ 1 નકલ મેળવે છે
અને તેથી S1 ફેરફાર કરી શકતાં નથી;
તેના બદલે, માત્ર તેના નકલ કે એસ સંગ્રહિત છે
જો તમે ઇચ્છો તો કાર્ય કરવા માટે એસ 1 સંશોધિત કરવાનો પ્રયત્ન કરવા માટે,
func એક વિદ્યાર્થી * એસ લેવાની જરૂર પડશે,
અને તમે આની જેમ સરનામા દ્વારા એસ 1, પાસ હશે.
વિદ્યાર્થી * એસ func અને S1.
ત્યાં બીજા સરનામા દ્વારા અહીં પસાર કારણ છે.
તો શું અમારી સ્ટ્રક્ટ 100 ક્ષેત્રો શામેલ છે?
દરેક એક સમય અમે func એક વિદ્યાર્થી પાસ
અમારા કાર્યક્રમ માટે func દલીલ એસ માં તે 100 બધા ક્ષેત્રોમાં નકલ કરવાની જરૂર છે,
પણ જો તે ઉપયોગ કરે છે તેમને ક્યારેય વિશાળ બહુમતી.
તેથી જો func વિદ્યાર્થી બદલવા પર કોઈ યોજના નથી,
જો હજી પણ સરનામા દ્વારા પસાર મૂલ્યવાન હોઈ શકે છે.
ઠીક છે, જો આપણે એક સ્ટ્રક્ટ માટે નિર્દેશક બનાવવા માંગો છો?
અમે કંઈક જેમ કરી શકે
વિદ્યાર્થી * S
malloc સમકક્ષ
વિદ્યાર્થી માપ.
હજુ પણ અહીં કામ કરે છે કે જે કદ નોટિસ.
તેથી અમે કેવી રીતે હવે તો ઉંમર સભ્ય ઍક્સેસ
બ્લોક કે એસ પોઇન્ટ?
તમે પ્રથમ કરવા લાગે શકે છે
* = S.age 4,
પરંતુ આ તદ્દન કામ કરશે નહિં.
જ્યારથી આ ખરેખર તરીકે અર્થઘટન કરવામાં આવશે
4 = કૌંસ માં * S.age,
જે પણ કમ્પાઇલ કરવામાં આવશે,
કારણ કે એસ એક જગ્યાએ અથવા સ્ટ્રક્ટ એક સ્ટ્રક્ટ માટે નિર્દેશક નથી,
અને તેથી કોઈ અહીં કામ કરશે નહિં.
અમે કરી શકે
(* એસ). 4 = વય
પરંતુ કૌંસ નકામી અને ગૂંચવણમાં મેળવી શકો છો.
Thankfully, અમે એક ખાસ તીર ઓપરેટર છે
કે કંઈક આના જેવું દેખાય છે
એસ> વય = 4.
વય સંદર્ભ આ રીતે 2
સમકક્ષ છે
અને અમે ખરેખર ક્યારેય તીર ઓપરેટર જરૂર નથી,
પરંતુ તે બનાવે વસ્તુઓ NICER જુઓ.
ત્યારથી એસ મેમરી કેટલાક બ્લોક કે સ્ટ્રક્ટ સમાવે છે એક નિર્દેશક છે,
તમે એસ> વય લાગે તરીકે નિર્દેશક તીર અનુસરી શકે છે
અને વર્ષની સભ્ય ગ્રેબ.
તેથી અમે ક્યારેય શા માટે સ્ટ્ર્ક્ટ્સ ઉપયોગ કરવો જોઇએ?
તે ચોક્કસપણે છે શક્ય માત્ર પૂર્ણાંકો આદિમ સાથે દૂર વિચાર,
અક્ષરો, પોઇંટરો અને જેમ
કે અમે ઉપયોગ કરી રહ્યા છો;
તેના બદલે એસ 1 અને S2 પહેલાં એક,
અમે age1, age2, NAME1, અને NAME2 હતી હોઈ શકે છે
અલગ ચલો પર છે.
આ માત્ર 2 વિદ્યાર્થીઓ સાથે સારું હોય છે,
પરંતુ જો આપણે 10 તેમને હતી?
અને જો બદલે શું માત્ર 2 ક્ષેત્રો,
વિદ્યાર્થી સ્ટ્રક્ટ 100 ક્ષેત્રો હતી?
GPa, અભ્યાસક્રમો, વાળ રંગ, લિંગ, અને તેથી.
તેના બદલે 10 ફક્ત સ્ટ્ર્ક્ટ્સ છે, અમે 1,000 અલગ ચલો જરૂર છે.
પણ, એક કાર્ય ધ્યાનમાં
જે 100 ક્ષેત્રો સાથે તેના માત્ર દલીલ સાથે સ્ટ્રક્ટ લે છે
અને બહાર બધા ક્ષેત્રો છાપે છે.
જો આપણે એક સ્ટ્રક્ટ ઉપયોગ નથી કર્યો,
દરેક એક સમય અમે તે કાર્ય કહી,
અમે તમામ 100 ચલો અંતે પસાર કરવાની જરૂર છે,
અને જો આપણે 1 વિદ્યાર્થી માટે 100 ચલો હોય છે,
અને 2 વિદ્યાર્થી માટે 100 ચલો,
અમે ખાતરી કરવા માટે અમે આકસ્મિક 1 વિદ્યાર્થી કેટલાક ચલો પાસ કરતું નથી જરૂર
અને 2 વિદ્યાર્થી કેટલાક ચલો.
તે અશક્ય છે એક સ્ટ્રક્ટ સાથે ભૂલ કરી,
કારણ કે તમામ 100 ચલો એક પેકેજમાં સમાયેલ છે.
જસ્ટ અંતિમ નોંધોનો એક દંપતી:
જો તમે આ બિંદુએ સુધી બધું, મહાન સમજી કર્યું છે.
વિડિઓ બાકીના 'સંપૂર્ણતા ખાતર માત્ર છે.
કારણ કે સ્ટ્ર્ક્ટ્સ નિર્દેશક કોઈપણ પ્રકારની પકડી શકે છે,
તેઓ પણ કાર્ય પોઇંટરો સમાવી શકે છે.
જો તમે પદાર્થ કેન્દ્રિત પ્રોગ્રામિંગની સાથે પરિચિત કરશો,
આ એક ઓબ્જેક્ટ લક્ષી શૈલીમાં કાર્યક્રમ સ્ટ્ર્ક્ટ્સ ઉપયોગ રસ્તો પૂરો પાડે છે.
અન્ય સમયે કાર્ય પોઇન્ટર પર વધુ.
પણ, ક્યારેક તમે 2 સ્ટ્ર્ક્ટ્સ હોઈ શકે છે
જેના વ્યાખ્યાઓ એક બીજા પર આધાર રાખે છે.
ઉદાહરણ તરીકે,
અમે સ્ટ્રક્ટ એક હોઇ શકે છે,
જે તરીકે ઓળખવામાં આવે છે
એક સ્ટ્રક્ટ બી એક નિર્દેશક,
સ્ટ્રક્ટ બી * એક્સ,
અને હવે અમે એક સ્ટ્રક્ટ બી હોઈ શકે છે
જે નિર્દેશક તરીકે વ્યાખ્યાયિત કરવામાં આવે છે
એક સ્ટ્રક્ટ એ,
સ્ટ્રક્ટ A * વાય
પરંતુ આ કમ્પાઇલ કરવામાં આવશે,
ત્યારથી સ્ટ્રક્ટ બી સમય કે સ્ટ્રક્ટ એક સંકલિત કરવામાં આવી રહી છે અસ્તિત્વમાં નથી.
અને જો આપણે સ્ટ્રક્ટ એ અને સ્ટ્રક્ટ સ્વેપ બી,
તો પછી અમે માત્ર એ જ સમસ્યા સાથે છોડી હો શકાય છે;
આ સમય સાથે હાલના નથી એ સ્ટ્રક્ટ.
આ ઉકેલવા માટે, અમે લખી શકો છો
સ્ટ્રક્ટ બી;
સ્ટ્રક્ટ એ વ્યાખ્યા પહેલા
આ એક આગળ જાહેરાત કહેવાય છે.
આ માત્ર દે ત્યારે કમ્પાઇલર ખબર છે કે
સ્ટ્રક્ટ બી માન્ય પ્રકાર છે કે જે પૂર્ણપણે પાછળથી અથવા અન્યત્ર વ્યાખ્યાયિત છે.
મારું નામ રોબ બોડેન છે, અને આ CS50 છે.
[CS50.TV]