सी निजी वैरिएबल प्राप्त करें और सेट करें विधि

Question

मैं सी में काम कर रहा हूं, और कुछ चर हैं जो मैं वैश्विक नहीं बनना चाहता हूं, लेकिन मैं उन लोगों के लिए तरीकों को प्राप्त करना और सेट करना चाहता हूं जिन्हें बाहर "ग्लोबली" तक पहुंचा जा सकता है फाइल का मैं जावा में ऐसा करने के लिए प्रयोग किया जाता है, लेकिन सी इस तरह से बहुत अलग है। असल में मैं ऐसा कुछ ढूंढ रहा हूं जो इस छद्म संहिता का पालन करता है, लेकिन मैं उन उदाहरणों के साथ कहीं भी नहीं ढूंढ पाया जो मैं देख सकता हूं।

main.c 
#include data.h 
set(b); 

datalog.c 
#include data.h 
get(b); 

data.c 
private int c; 
set(b){ 
    c = b; 
} 
get(c){ 
    return c; 
} 

Answer 1

आप चर static बनाते हैं। जब एक वैश्विक चर static बनाया जाता है, तो इसका दायरा वर्तमान फ़ाइल तक ही सीमित है।

फ़ाइल का नाम:: main.c

#include <stdio.h> 

#include "header.h" 

extern int get(); 
extern void set(int); 

int main() 
{ 
    set(10); 
    printf("value = %d \n", get()); 
    set(20); 
    printf("value = %d \n", get()); 
    set(30); 
    printf("value = %d \n", get()); 
    set(40); 
    printf("value = %d \n", get()); 
    return 0; 
} 

फ़ाइल का नाम: header.h

#include <stdio.h> 

int get(void); 
void set(int); 

फ़ाइल का नाम: हैडर

एक उदाहरण इस प्रकार है।ग

#include "header.h" 

static int value = 0; 

int get(void) 
{ 
    return value; 
} 

void set(int new_value) 
{ 
    value = new_value; 
} 

आउटपुट:

$ gcc -Wall -o main main.c header.h header.c 
$ ./main 
value = 10 
value = 20 
value = 30 
value = 40 
$ 

Answer 2

आप लिख सकते हैं:

static int c; 

इस तरह, "सी" चर "ओ" निर्यात नहीं होंगे।

Answer 3

यदि आप सी में निजी चर चाहते हैं, तो ऐसी कई तकनीकें हैं जो एक निजी चर का अनुमान लगा सकती हैं, लेकिन सी भाषा में वास्तव में "सुरक्षा" अवधारणा नहीं है जो निजी, सार्वजनिक, संरक्षित (सी ++ कर देता है)।

सी किसी भी चर (यह सी में यह आवश्यक हैं) की नाम दिखाई देंगे ताकि आप प्रकार चर की (निर्माण काफी मुश्किल अपसंदर्भन) छुपा जानकारी के विचार के साथ यह दृष्टिकोण होना चाहिए। करने के लिए परिभाषित वास्तविक चर प्रकार वाला void* के रूप में चर केवल एक .c मॉड्यूल में जाना जाता है

एक चाल है।

/* somefile.h */ 

extern void* counter; 

/* somefile.c */ 

#include "somefile.h" 

int actualCounter = 0; 
void* counter = &actualCounter; 

/* otherfile.c */ 

#include "somefile.h" 

// we can see "counter", but we cannot "use" it here; because we don't have access 
// to the real "hidden" type of "int". 

एक बेहतर तरीका की तरह तो कई वेरिएंट है

/* person.h */ 

struct s_person; 

typedef Person struct s_person; 

Person* new_Person(char* name); 
void delete_Person(Person* person); 

void Person_setName(Person* person, char* name); 
char* Person_getName(Person* person); 

/* person.c */ 

struct s_person { 
    char* name; 
}; 

Person* new_Person(char* name) { 
    Person* object = (Person*)malloc(sizeof(struct s_person)); 
    // duplicate the string for more security, otherwise constructor 
    // could manipulate the "private" string after construction. 
    object->name = strdup(name); 
    return object; 
} 

void delete_Person(Person* person) { 
    // some implementations pass a Person** to set the reference to 0 
    // this implementation requires that the caller sets his own references to 0 
    free(person->name); 
    free(person); 
} 

void Person_setName(Person* person, char* name) { 
    // free the old 
    free(person->name); 
    // duplicate the new to provide "out of simulated class" modification by malicious 
    // name setter. 
    person->name = strdup(name); 
} 

char* Person_getName(Person* person) { 
    // must return a copy, otherwise one can manipulate name 
    // from reference provided by Person_getName(...); 
    return strdup(person->name); 
} 

/* otherfile.c */ 

#include "Person.h" 

/* Now we can hold Person "simulated objects", but we cannot */ 
/* manipulate their "state" without using the C simulated object */ 
/* methods */ 

int main(int argc, char** argv) { 

    Person* bob = new_Person("bob"); 
    printf("%s\n", Person_getName(bob)); 
    delete_Person(bob); 
    // critical or we hold a pointer to freed memory. 
    bob = 0; 

    return 0; 
} 

तकनीक इस तरह struct कीवर्ड का उपयोग इस विचार का विस्तार, और छद्म तरीकों बनाने के लिए, किसी व्यक्ति के लिए एक "सार्वजनिक struct है "एक निजी * सूचक" निजी संरचना "के साथ सूचक। एक "सार्वजनिक संरचना" (पॉलिमॉर्फिज्म का समर्थन करने के लिए एक कदम) में फ़ंक्शन पॉइंटर्स के रूप में "विधियों" को शामिल करना है, वास्तव में एक पूर्ण और उचित सी ++ प्रकार प्रणाली लिखना है जो सी ++ के रूप में चीजों को हल करने का प्रयास करता है (कक्षा पदानुक्रम, polymorphisim, देर से बाध्यकारी, सूचना छिपाने, आदि)।

मूल रूप से, आप प्राप्त कर सकते हैं कुछ "वस्तु उन्मुख सत्ता" बहुत ज्यादा काम के बिना, लेकिन आप -ornamentation के और अधिक सुविधाओं को जोड़ने के रूप में, आप और अधिक गोंद कोड जोड़ देगा (जब तक यह है बहुत सरल वास्तव में एक का उपयोग करने के ऑब्जेक्ट उन्मुख प्रोग्रामिंग भाषा)।

Answer 4

अपने उदाहरण से, आप इस जानकारी के साथ कुछ struct उपयोग करने का प्रयास कर सकते हैं। structclass जैसा है केवल सार्वजनिक सदस्य चर (यानी कोई फ़ंक्शन नहीं)। तो कुछ के रूप में

#include <stdio.h> 

typedef struct _somestruct 
{ 
    int c; 
} theStruct; 

int getC(theStruct* obj) 
{ 
    if(obj == NULL) 
    return -1; 
    return obj->c; 
} 

void setC(theStruct* obj, int val) 
{ 
    if(obj == NULL) 
    return; 
    obj->c = val; 
} 

int main() 
{ 
    theStruct myStruct; 
    setC(&myStruct, 5); 
    printf("%d\n", getC(&myStruct)); 
    return 0; 
} 

इस प्रकार आप देख सकते हैं पर विचार करें, C केवल वस्तुओं और कार्यों के साथ काम करता है। लेकिन सभी फ़ाइलों में एक वैश्विक चर प्राप्त करने के लिए, static int c = 0;

ऊपर दिया गया उदाहरण लगभग उतना करीब है जितना आप संभवतः "जावा-स्टाइल" सम्मेलन में प्राप्त कर सकते हैं।

Answer 5

static int c; 

int get(void) { 
    return c; 
} 

int set(int n) { 
    c = n; 
}