2010-09-01 7 views
16

मुझे सर्कुलर बफर को लागू करने के लिए बहुत से टेम्पलेट्स और जटिल डेटा संरचनाएं दिखाई देती हैं।मैं सी/सी ++ में एक साधारण पूर्णांक परिपत्र बफर कैसे कोड करूं?

मैं 5 संख्याओं के लिए एक सरल पूर्णांक परिपत्र बफर कैसे कोड करूं?

मैं सोच रहा हूं कि सी सबसे सरल है?

धन्यवाद।

+7

कोड की जटिलता यह सुनिश्चित करती है कि आप कितना सुरक्षित और मजबूत होना चाहते हैं। क्या आप इसे उदाहरण के लिए अंडरफ्लो/ओवरफ्लो को रोकना चाहते हैं? –

+3

नोट: एक गोलाकार (अंगूठी) बफर एक परिपत्र * कतार * से अलग है। –

+0

मुझे बस कुछ डेटा के 5 अंतिम मूल्यों को स्टोर करने की आवश्यकता है, इसलिए जो कुछ भी करने के लिए बेहतर डिज़ाइन है। –

उत्तर

25

5 पूर्णांकों में से एक सरणी, buffer है। अगले तत्व में एक सूचकांक ind है। जब आप जोड़ने के लिए,

buffer[ind] = value; 
ind = (ind + 1) % 5; 
+6

व्यक्तिगत अनुभव फ़ाइल से, आपको सावधान रहना होगा कि भारत नकारात्मक नहीं है। यदि आप दूसरी पंक्ति को "ind = (max (0, ind)% 1) + 5 में बदलते हैं;", आपको इंडेक्स के लिए नकारात्मक मानों की चिंता करने की आवश्यकता नहीं है। –

+2

आप सिर्फ इंडेंट होने के लिए क्यों सेट नहीं करते हैं? इससे आपकी समस्या अधिक कुशलता से हल हो जाएगी यदि केवल जोड़ शामिल हैं – Triskeldeian

1

कर अपने बफर के आकार और डेटा प्रकार तय कर रहे हैं, एक सरल सरणी सब है आप की जरूरत:

int buffer[5]; 

कि एक जोड़े को संकेत में जोड़ें:

int* start = &buffer[0]; 
int* end = &buffer[4]+1; 
int* input = start; 
int* output = start; 
11

एक सरणी लें, arr, एक सूचकांक idx, और एक काउंटर, num

foo डालने के लिए, arr[idx++] = foo; idx %= buffer_len; num++; कहें।

foo में किसी आइटम को पढ़ने के लिए, foo = arr[(idx-num)%buffer_len]; num--; कहें।

सीमा जांच जोड़ें।

+0

आपको num और idx की आवश्यकता नहीं है। – user3467349

1
int rI =0; 
int wI=0; 
#define FIFO_SIZE 3 
int checkAvail() 
{ 
int avail=0; 

if(wI<rI) 
    avail= (rI-wI); 
else 
    avail = (FIFO_SIZE-wI+rI); 
return avail; 
} 

int addFIFO(int *a, int val) 
{ 
if(checkAvail()>0) 
{ 
    a[wI]=val; 
    wI++; 
    if(wI>FIFO_SIZE) 
     wI=0; 
} 
else 
{ 
    printf("FIFO full"); 
} 
return 0; 
} 
int remFIFO(int *a) 
{ 
int val; 
if((FIFO_SIZE-checkAvail()>0)) 
{ 
    val =a[rI]; 
    rI++; 
    if(rI>FIFO_SIZE) 
     rI=0; 
} 
else 
{ 
    printf("FIFO empty"); 
} 
return 0; 
} 
int main(array<System::String ^> ^args) 
{ 
int FIFO_ARRAY[FIFO_SIZE]={}; 
addFIFO(FIFO_ARRAY,1); 
addFIFO(FIFO_ARRAY,2); 
addFIFO(FIFO_ARRAY,3); 
addFIFO(FIFO_ARRAY,4); 
remFIFO(FIFO_ARRAY); 
remFIFO(FIFO_ARRAY); 
remFIFO(FIFO_ARRAY); 
remFIFO(FIFO_ARRAY); 
remFIFO(FIFO_ARRAY); 
} 
संबंधित मुद्दे