Theory
જે finale subject એ વચન આપ્યું
Marks program નો data જુઓ, સામાનની જેમ વિખરાયેલો: roll numbers એક array માં, names એક char grid માં, marks બીજા array માં, grades ચોથામાં. Student 17 એ ચાર index-17s નો એક સંયોગ છે. એક array sort કરો અને બાકી ભૂલી જાઓ, તો Riya ને Aman નો grade મળી જાય છે.
હકીકત જે ઇચ્છે છે એ એક record છે: આ roll, આ name, આ marks, સાથે સાથે મુસાફરી કરતા.
C નો જવાબ છે struct, આ subject નો છેલ્લો અને સૌથી job-relevant idea.
Theory
દરેક student ની એક file
College office બધાના rolls નું એક register, બધાના names નું બીજું, marks નું ત્રીજું નથી રાખતું. એ દરેક student ની એક FILE રાખે છે જેમાં દરેક detail અંદર હોય, અને એવી files નો એક કબાટ. Struct એ જ file છે (ભેળસેળ સામગ્રી, એક cover); structs નું array એ જ કબાટ છે. Array એ કહ્યું હતું "60 boxes, એક જ type"; struct કહે છે "એક bundle, અલગ types". બંને મળીને કંઈ પણ model કરી શકે છે.
Theory
Define, declare, initialize, access
Type define કરો (એક template, હજી કોઈ memory નહીં):
struct student {
int roll;
char name[20];
int marks;
char grade;
};
Declare variables (હવે memory): struct student s1;
Initialize: struct student s1 = {42, "Riya", 78, 'A'};
Dot થી access: s1.marks = 92; printf("%s", s1.name); અને name member માટે, strcpy(s1.name, "Riya") (arrays = ની ના પાડે છે, હંમેશની જેમ).
Practical
Marks program, છેલ્લું રૂપ
#include <stdio.h>
struct student {
int roll;
char name[20];
int marks;
char grade;
};
int main() {
struct student klass[3] = {
{1, "Riya", 78, 'A'},
{2, "Aman", 55, 'B'},
{3, "Zoya", 91, 'A'}
};
int i;
for (i = 0; i < 3; i++)
printf("%d %-6s %3d %c\n", klass[i].roll,
klass[i].name, klass[i].marks, klass[i].grade);
return 0;
}This example runs in Gri-Learn on the web, where you can edit it and see the output.
Quiz
struct student { int roll; char name[20]; int marks; char grade; }; ફક્ત આ definition કેટલી memory reserve કરે છે?
- કોઈ નહીં: definition એ template છે; memory variable declaration સાથે આવે છે
- તરત 29 bytes
- semicolon માટે એક byte
- name array માટે 20 bytes
Show the answer
કોઈ નહીં: definition એ template છે; memory variable declaration સાથે આવે છે
Struct define કરવું C ને એક નવો TYPE શીખવે છે, એક stencil, અને stencils કંઈ રોકતા નથી. Memory દરેક VARIABLE પ્રમાણે allocate થાય છે: struct student s1; સાચા bytes કાપે છે (લગભગ members નો સરવાળો, સાથે alignment padding). "શું definition memory allocate કરે છે?" એ theory papers નો પાક્કો સવાલ છે, અને જવાબ એક સાફ ના છે.
Think first
કોઈને ખોયા વગર sort કરો
bubble sort નો temp વાળો swap યાદ છે? struct ની દુનિયામાં, class ને marks થી એવી રીતે કેવી રીતે sort કરવો કે names અને grades એમના marks સાથે ચાલે? Swap નો temp શું છે?
Show the answer
આખા records swap કરો: struct student temp = klass[j]; klass[j] = klass[j+1]; klass[j+1] = temp;, structs, arrays થી ઉલટા, = assignment ને પરવાનગી આપે છે, દરેક member એકસાથે copy કરતા. Parallel-arrays વાળો bug (Riya ને Aman નો grade) અશક્ય થઈ જાય છે: file એક એકમ તરીકે ચાલે છે. આ struct-sort એ marks program ની graduation પરીક્ષા છે, અને એક સાચો lab સવાલ.
Theory
Union: એ જ syntax, વહેંચાયેલો ઓરડો
Keyword બદલો અને કંઈક મૂળથી બદલાઈ જાય છે:
union value {
int i;
float f;
char c;
};
એક union ના બધા members એક જ memory block વહેંચે છે, સૌથી મોટા member પ્રમાણે sized. u.i = 65 લખો, અને u.f તથા u.c એ જ bytes ને જોઈ રહ્યા છે: u.f = 2.5 લખો અને u.i overwrite થઈ જાય છે, garbage. એક drawer જેની સામગ્રીનું label બદલાય છે: એક વખતે એક member જીવંત. એનો હેતુ: memory બચાવવી જ્યારે value હંમેશા ઘણા types માંથી ફક્ત એક હોય (embedded systems, variant records).
Quiz
union value u; u.i = 100; u.f = 2.5; printf("%d", u.i); શું print થાય છે?
- Garbage: u.f લખવાથી એ વહેંચાયેલા bytes overwrite થઈ ગયા જેમાં 100 હતું
- 100: દરેક member પોતાનું storage રાખે છે
- 2: u.f, u.i માં round થઈ જાય છે
- 102: members ઉમેરાઈ જાય છે
Show the answer
Garbage: u.f લખવાથી એ વહેંચાયેલા bytes overwrite થઈ ગયા જેમાં 100 હતું
એક ઓરડો, એક રહેવાસી: u.f અંદર આવ્યો અને u.i નું 100 તૂટી ગયું; હવે u.i વાંચવું float bytes ને એક int તરીકે ફરી વાંચે છે, garbage. એક STRUCT માં બંને members ના પોતાના ઓરડા હોય અને 100 બચી જાત. આ overwrite trace એ THE union exam સવાલ છે, અને struct-સામે-union નું સૌથી તીક્ષ્ણ પ્રદર્શન.
Watch out
Marks ક્યાં કપાય છે
struct definition ના closing brace પછી semicolon ભૂલવો: એક પ્રખ્યાત ગૂંચવનારો error cascade. ખોટી વસ્તુ પર dot: klass.marks ખોટું છે, klass[i].marks સાચું, array element એ જ struct છે. name member પર =: s1.name = "Riya" નિષ્ફળ (array!), એને strcpy કરો. Union માં બેદરકારી: ફક્ત છેલ્લે-લખેલો member વાંચવા લાયક છે; બીજો વાંચવો garbage છે, error નહીં.
Theory
તમે database થી એક keyword દૂર છો
struct student ને જુઓ અને આંખો ઝીણી કરો: roll, name, marks, grade... એ એક database ROW છે, અને klass[60] એક TABLE છે. BCA105 નું SQL તમને આ જ idea એક query language સાથે આપશે, અને આગળ તમે જે પણ backend job કરશો એ આવા જ records ફેરવે છે. આગળનો lesson subject ને બંધ કરે છે: struct સામે union, ઔપચારિક રીતે, એ comparison table માં જે exams માંગે છે.
Summary
Key takeaways
- Struct અલગ types ને એક record type માં બાંધે છે; definition કંઈ allocate કરતી નથી.
- Memory માટે declare કરો, {} થી initialize, dot થી members access: s1.marks.
- structs ના arrays (klass[60]) એ marks program નું સાચું રૂપ છે; structs આખા-record copy માટે = ને પરવાનગી આપે છે.
- char-array members માટે strcpy; એમના પર ક્યારેય = નહીં.
- એક union ના members એક memory block વહેંચે છે (સૌથી મોટાનું size): એક વખતે એક જીવંત.
- એક union member લખવાથી બાકીના corrupt થાય છે, struct ના members અલગ રહે છે.
- યાદ રાખવાની યુક્તિ: દરેક student ની એક file; union એ એક drawer છે, નવા label વાળો.