C भाषा में Structures एक डेटा टाइप है जो अलग-अलग डेटा टाइप के वेरिएबल्स को एक संगठित रूप में संग्रहित करता है। यह C में उपलब्ध प्राथमिक डेटा टाइप में से एक है जिसमें बड़ी और जटिल डेटा स्ट्रक्चर्स को प्रबंधित किया जाता है।
Structure एक डेटा टाइप होता है जो संबंधित डेटा इलेमेंट को एक साथ रखता है जो कि समूह के रूप में थोड़े से वेरिएबल्स के लिए लागू होता हैं।
Structure को संबंधित वेरिएबल्स की एक समूह के रूप में परिभाषित किया जाता है। इसके बाद, इसका उपयोग इन संबंधित वेरिएबल्स को संदर्भित करने और उन्हें प्रोसेस करने के लिए किया जाता है।
Structure डेटा टाइप को बनाने के लिए, struct की घोषणा के साथ एक नाम दिया जाता है जो Structure के लिए एक Identifier के रूप में काम करता है। Structure के अंदर वेरिएबल्स घोषित किए जाते हैं जिनकी घोषणा अन्य डेटा टाइप की तरह होती है।
इसके बाद Structure वेरिएबल को घोषित किया जाता है।
C भाषा में, Structure को struct की घोषणा के साथ परिभाषित किया जाता है। संरचना बनाने के लिए, आप निम्नलिखित संगति का उपयोग कर सकते हैं।
struct <structure_name> {
data_type1 member_name1;
data_type2 member_name2;
.
.
data_typeN member_nameN;
};
यहां, <structure_name> आपके Structure के नाम को दर्शाता है, जिसे आप अपनी पसंद के अनुसार नामित कर सकते हैं।
data_type1, data_type2 और data_typeN डेटा टाइप होते हैं, जो आप वेरिएबल्स के लिए उपयोग करना चाहते हैं। member_name1, member_name2 और member_nameN Structure के सदस्यों के नाम होते हैं जो उसमें शामिल होते हैं। आप अपने Structure में चाहते हैं उनकी संख्या एवं नाम को अपनी सुविधा के अनुसार बदल सकते हैं।
इसके बाद आप Structure के नए वेरिएबल को उस Structure के द्वारा परिभाषित किए गए सदस्यों के संयोजन से बना सकते हैं।
यहां एक उदाहरण है जो इसकी संक्षिप्त जानकारी देता है।
#include <stdio.h>
#include <string.h>
struct Student {
int rollno;
char name[50];
float marks;
};
int main() {
struct Student s1;
s1.rollno = 1;
strcpy(s1.name, "John");
s1.marks = 89.5;
printf("Roll No: %d\n", s1.rollno);
printf("Name: %s\n", s1.name);
printf("Marks: %f\n", s1.marks);
return 0;
}
Structure Members को Accessing करना
C भाषा में, Structure Members को उनके नाम और डॉट (.) ऑपरेटर का उपयोग करके Access किया जाता है।
यदि आप एक Structure का नाम और उसके सदस्य का नाम जानते हैं, तो आप निम्न विधि का उपयोग करके Structure Member को Access कर सकते हैं।
<structure_name>.<member_name>
यहां एक उदाहरण है जो संरचना सदस्यों को एक्सेस करने का तरीका दर्शाता है।
#include <stdio.h>
#include <string.h>
struct Student {
int rollno;
char name[50];
float marks;
};
int main() {
struct Student s1;
s1.rollno = 1;
strcpy(s1.name, "John");
s1.marks = 89.5;
printf("Roll No: %d\n", s1.rollno);
printf("Name: %s\n", s1.name);
printf("Marks: %f\n", s1.marks);
return 0;
}
इस उदाहरण में, s1 नाम का एक Structure Student है जिसकी तीन सदस्य हैं: rollno, name और marks।
s1 के सदस्यों को Access करने के लिए, हमने निम्नलिखित सामान्य संरचना का उपयोग किया है:
s1.rollno
s1.name
s1.marks
इन संरचना सदस्यों को उनके नाम और डॉट (.) ऑपरेटर का उपयोग करके Access किया जाता है।
जब आप उन्हें printf() फंक्शन के साथ उपयोग करते हैं, तो आप उनकी मानों को डिस्प्ले करते हैं।
उदहारण
संरचना सदस्यों को Access करने के लिए निम्नलिखित उदाहरण देखें।
#include <stdio.h>
#include <string.h>
struct Employee {
int emp_id;
char name[50];
float salary;
};
int main() {
struct Employee e1 = {101, "John Doe", 5000.00};
struct Employee e2;
e2.emp_id = 102;
strcpy(e2.name, "Jane Smith");
e2.salary = 6000.00;
printf("Employee 1:\n");
printf("ID: %d\n", e1.emp_id);
printf("Name: %s\n", e1.name);
printf("Salary: %f\n", e1.salary);
printf("\nEmployee 2:\n");
printf("ID: %d\n", e2.emp_id);
printf("Name: %s\n", e2.name);
printf("Salary: %f\n", e2.salary);
return 0;
}
इस उदाहरण में, Employee नाम का एक Structure है जिसकी तीन सदस्य हैं: emp_id, name और salary।
e1 एक Structure है जो संरचना के सभी सदस्यों को अपने अंदर संग्रहित करता है, जबकि e2 कोई मान नहीं रखता। e1 को सीधे इनिशियलाइज़ किया गया है, जबकि e2 को स्वयं अनुकूलित ढंग से फ़ील्डों को मान देने के बाद इनिशियलाइज़ किया गया है।
संरचना सदस्यों को Access करने के लिए, हमने निम्नलिखित सामान्य संरचना का उपयोग किया है:
e1.emp_id
e1.name
e1.salary
e2.emp_id
e2.name
e2.salary
इन संरचना सदस्यों को उनके नाम और डॉट (.) ऑपरेटर का उपयोग करके Access किया जाता है।
जब आप उन्हें printf() फंक्शन के साथ उपयोग करते हैं, तो आप उनकी मानों को डिस्प्ले करते हैं।
Structures as Function Arguments
C भाषा में, आप Structures को एक फ़ंक्शन के एर्ग्यूमेंट के रूप में भी भेज सकते हैं। इससे आपके पास एक संरचना फ़ंक्शन के भीतर उपलब्ध होती है जो संरचना में सदस्यों के साथ काम करती है।
Structure फ़ंक्शन के एक या अधिक एर्ग्यूमेंट होते हैं, और एक Structure के सदस्यों के विवरण को भेजा जाता है। संरचना फ़ंक्शन के भीतर, संरचना सदस्यों को एक्सेस करने के लिए डॉट ऑपरेटर का उपयोग किया जाता है।
इसके एक उदाहरण के रूप में, निम्नलिखित कोड संरचना को फ़ंक्शन के एक एर्ग्यूमेंट के रूप में भेजने का उदाहरण देता है:
#include <stdio.h>
#include <string.h>
struct Employee {
int emp_id;
char name[50];
float salary;
};
void display(struct Employee emp) {
printf("Employee details:\n");
printf("ID: %d\n", emp.emp_id);
printf("Name: %s\n", emp.name);
printf("Salary: %f\n", emp.salary);
}
int main() {
struct Employee e = {101, "John Doe", 5000.00};
display(e);
return 0;
}
इस उदाहरण में, Employee संरचना का एक फ़ंक्शन display() बनाया गया है जो संरचना सदस्यों को Access करता है और उन्हें दिखाता है। main() फ़ंक्शन में, Employee संरचना का एक ऑब्जेक्ट e बनाया गया है जो display() फ़ंक्शन के ऑब्जेक्ट के रूप में भेजा जाता है। display() फ़ंक्शन के भीतर, Employee संरचना के सदस्यों को डॉट ऑपरेटर का उपयोग करके एक्सेस किया जाता है और उन्हें दिखाया जाता है।
यह प्रोग्राम निम्न आउटपुट देगा:
Employee details:
ID: 101
Name: John Doe
Salary: 5000.000000
इस प्रकार, आप संरचनाएं फ़ंक्शन के एर्ग्यूमेंट के रूप में भेज सकते हैं और संरचना सदस्यों को उनकी वैल्यू को पाने और उनसे काम करने के लिए डॉट ऑपरेटर का उपयोग कर सकते हैं।
Pointers to Structures
C भाषा में, संरचनाओं को पॉइंटर के माध्यम से भी एक्सेस किया जा सकता है। यहां, संरचना पॉइंटर संदर्भ के रूप में काम करता है और उसके माध्यम से संरचना सदस्यों को एक्सेस किया जाता है।
पॉइंटर को संरचना से बिंदिंग करने के लिए, संरचना प्रकार के बाद एक अंतरण वर्णक का उपयोग किया जाता है। यह अंतरण वर्णक पॉइंटर का नाम होता है और इसे * ऑपरेटर के साथ उपयोग किया जाता है।
यहां एक उदाहरण है जो पॉइंटर को एक संरचना से बाइंड करता है और संरचना सदस्यों को पहुँचता है:
#include <stdio.h>
#include <string.h>
struct Employee {
int id;
char name[50];
float salary;
};
int main() {
struct Employee emp = {1, "John Doe", 5000.00};
struct Employee *ptr_emp = &emp; // define structure pointer & store address of structure
printf("Employee details:\n");
printf("ID: %d\n", ptr_emp->id); // access member of structure
printf("Name: %s\n", ptr_emp->name);
printf("Salary: %f\n", ptr_emp->salary);
return 0;
}
इस प्रोग्राम में, Employee संरचना को emp नामक एक वेरिएबल में इनिशियलाइज़ किया गया है। फिर, ptr_emp नामक एक पॉइंटर बनाया जाता है जो emp संरचना का पता लगाता है।
printf() फ़ंक्शन के माध्यम से, ptr_emp पॉइंटर से संरचना सदस्यों को पहुँचा जाता है। ptr_emp->id संरचना के id सदस्य को पहुँचता है, ptr_emp->name संरचना के name सदस्य को पहुँचता है और ptr_emp->salary संरचना के salary सदस्य को पहुँचता है।
ध्यान दें कि -> ऑपरेटर संरचना पॉइंटर संदर्भ के लिए उपयोग किया जाता है, जबकि . ऑपरेटर संरचना संदर्भ के लिए उपयोग किया जाता है।
संरचना पॉइंटर संदर्भ का उपयोग करने से, प्रोग्रामर संरचना सदस्यों को बड़े पैमाने पर अद्वितीय वेरिएबलों के रूप में नहीं एक्सेस करते हैं, बल्कि वे उन्हें पॉइंटर के माध्यम से एक्सेस करते हैं जो कि संरचना के संदर्भ में हैं।
Pointers to structures को define करना
Pointers to structures को संरचना पॉइंटर द्वारा प्रतिनिधित किया जाता है। संरचना पॉइंटर एक पोइंटर होता है जो संरचना के संदर्भ में होता है।
संरचना पॉइंटर को निम्नलिखित रूप से घोषित किया जा सकता है:
struct Employee {
int id;
char name[50];
float salary;
};
struct Employee *ptr_emp; // structure pointer declaration
यहाँ, ptr_emp एक संरचना पॉइंटर है जो Employee संरचना के संदर्भ में है।
एक संरचना पॉइंटर का उपयोग संरचना सदस्यों तक पहुँच करने के लिए किया जाता है।
Structure variable में address को store करना
C भाषा में संरचना चरण के विकल्प के रूप में उपलब्ध हैं, जिससे हम एक संरचना में संग्रहीत डेटा को दुनिया भर में संग्रहीत और अद्यतन कर सकते हैं। यदि हम एक संरचना का एक प्रतिनिधित बनाना चाहते हैं जो उस संरचना को संदर्भित करता है, तो हमें संरचना चरण में एक संरचना चरण बनाना चाहिए।
जब हम एक संरचना के लिए एक चरण बनाते हैं, तो हम संरचना चरण में एक वेरिएबल बनाते हैं जो संरचना को संदर्भित करता है। इसके बाद, हम इस वेरिएबल के पते का उपयोग करके इस संरचना को संदर्भित कर सकते हैं।
उदाहरण के लिए, यदि हम एक संरचना Employee का चरण बनाते हैं, तो हम उसके लिए एक वेरिएबल बना सकते हैं जैसे emp नामक वेरिएबल। इसके बाद, हम & ऑपरेटर का उपयोग करके इस संरचना चरण के पते को ले सकते हैं और इसे एक पॉइंटर में संग्रहीत कर सकते हैं।
उदाहरण के लिए:
struct Employee {
int id;
char name[50];
float salary;
};
int main() {
struct Employee emp; // structure variable
struct Employee *ptr_emp; // pointer to structure
ptr_emp = &emp; // store address of structure variable
Structure के member को access करना
C भाषा में structure के members को access करने के लिए डॉट (.) या arrow (->) ऑपरेटर का उपयोग किया जाता है।
डॉट (.) ऑपरेटर:
यदि structure का variable सीधे कॉन्ट्रोल द्वारा ही पहुंचना चाहिए तो "." ऑपरेटर का उपयोग किया जाता है। जैसे:
struct Person {
char name[50];
int age;
};
struct Person p;
p.age = 25;
strcpy(p.name, "John");
Arrow (->) ऑपरेटर:
यदि structure का pointer variable है तो arrow (->) ऑपरेटर का उपयोग किया जाता है। जैसे:
struct Person {
char name[50];
int age;
};
struct Person *p;
p = (struct Person*) malloc(sizeof(struct Person));
p->age = 25;
strcpy(p->name, "John");
यहां, "->" ऑपरेटर का उपयोग करके structure pointer p में age और name को assign किया जा रहा है।
Pointers to Structures का उदाहरण
C भाषा में structure के members को access करने के लिए डॉट (.) या arrow (->) ऑपरेटर का उपयोग किया जाता है।
डॉट (.) ऑपरेटर:
यदि structure का variable सीधे कॉन्ट्रोल द्वारा ही पहुंचना चाहिए तो "." ऑपरेटर का उपयोग किया जाता है। जैसे:
struct Person {
char name[50];
int age;
};
struct Person p;
p.age = 25;
strcpy(p.name, "John");
Arrow (->) ऑपरेटर:
यदि structure का pointer variable है तो arrow (->) ऑपरेटर का उपयोग किया जाता है। जैसे:
struct Person {
char name[50];
int age;
};
struct Person *p;
p = (struct Person*) malloc(sizeof(struct Person));
p->age = 25;
strcpy(p->name, "John");
यहां, "->" ऑपरेटर का उपयोग करके structure pointer p में age और name को assign किया जा रहा है।
Pointers to Structures का उदाहरण
एक स्ट्रक्चर में अन्य स्ट्रक्चर के पॉइंटर को संग्रहीत करने के लिए, C में पॉइंटर टू स्ट्रक्चर का उपयोग किया जा सकता है। यह पॉइंटर के उपयोग से हमें एक स्ट्रक्चर के सभी मेंबरों तक पहुंच मिलती है।
यहां एक उदाहरण दिया गया है जो पॉइंटर टू स्ट्रक्चर का उपयोग दिखाता है:
#include <stdio.h>
#include <string.h>
struct student {
int id;
char name[20];
float percentage;
};
int main() {
struct student s1;
struct student *ptr;
s1.id = 1;
strcpy(s1.name, "John");
s1.percentage = 80.5;
ptr = &s1;
printf("Student Id is: %d\n", ptr->id);
printf("Student Name is: %s\n", ptr->name);
printf("Student Percentage is: %f\n", ptr->percentage);
return 0;
}
इस उदाहरण में, स्ट्रक्चर student को परिभाषित किया गया है जो छात्र की जानकारी को संग्रहीत करता है। फिर s1 नाम के स्ट्रक्चर वेरिएबल को बनाया जाता है। उसके बाद ptr नाम के पॉइंटर को &s1 द्वारा s1 स्ट्रक्चर के पते में सेट किया जाता है।
अंत में, ptr->id, ptr->name और ptr->percentage के माध्यम से पॉइंटर के द्वारा स्ट्रक्चर s1 के सभी मेंबरों तक पहुंच की जाती है और उनकी मान छापी जाती है।
