코딩도사의 코드정리

template <typename Node>
class CircularQueue
{
private:
    Node* node; // 노드 배열
    int capacity; // 큐의 용량
    int front; // 전단의 인덱스
    int rear; // 후단의 인덱스
public:
    CircularQueue(int capacity)
    {
        this->capacity = capacity + 1; // 노드 배열의 크기는 실제 용량에서 1을 더한 크기 (더미 공간 때문)
        node = new Node[this->capacity]; // Node 구조체 capacity + 1개를 메모리 공간에 할당한다
        front = 0; rear = 0; // 전단과 후단의 초기화
    }
    
    ~CircularQueue()
    {
        delete []node; // 노드 배열 소멸
    }
    void clear()
    {
        front = rear = 0;
    }
    void enqueue(const Node& data)
    {
        int pos; // 데이터가 들어갈 인덱스
        pos = rear;
        rear = (rear + 1) % (capacity);
        node[pos] = data; // pos 번째의 노드의 데이터에 data를 대입한다
    }
    Node dequeue() {
        int pos = front; // pos에 전단의 인덱스 대입
        front = (front + 1) % capacity;
        return node[pos]; // 제외되는 데이터를 반환한다
    }
    int getSize() {
        if (front <= rear) // 전단의 인덱스가 후단의 인덱스와 같거나 그보다 작다면
            return rear - front; // 후단의 인덱스에서 전단의 인덱스를 뺀값을 반환한다
        else // 전단의 인덱스가 후단의 인덱스보다 크다면
            return capacity - front + rear; // 용량에서 전단의 인덱스를 뺀 뒤에 후단의 인덱스를 더한 값을 반환한다
    }
    bool isEmpty() {
        return front == rear; // 전단의 인덱스와 후단의 인덱스가 같을 경우 true, 아니면 false
    }
    bool isFull() {
        return front == (rear + 1) % capacity;
    }
    int getRear() { return rear; }
    int getFront() { return front; }
    vector<Node> getTotalData()
    {
        int tempFront = front;
        vector<Node> T;
        while(tempFront != rear)
        {
            T.push_back(node[tempFront]);
            tempFront = (tempFront + 1) % capacity;
        }
        return T;
    }

    //  void show()
    //  {
    //      int tempFront = front;
    //      while(tempFront != rear)
    //      {
    //          cout << node[tempFront].data << "/";
    //
    //          tempFront = (tempFront + 1) % capacity;
    //      }
    //      cout << endl;
    //  }
};

일반적으로 new/delete 를 통해서 메모리를 할당하는것은 비용을 발생시키고

보기에 위험해 보입니다.

C/C++ 에선 메모리를 할당 하기 위해서 시스템 콜(OS 내부 함수를 요청)을 해야만 하는데 이는 생각보다 큰 비용을 발생 시킵니다. 그래서 할당을 미리 해놓고 꺼내오고 해제된 메모리를 다시 쓰는 방식으로 재활용을 해야하는데, 라이브러리를 잘 짜기가 힘이 듭니다.

boost 로 해결할 수 있습니다.

#include <iostream>
#include <boost/pool/pool.hpp>
#include <boost/pool/object_pool.hpp>
using namespace std;


struct SomeObject
{
    SomeObject()  { static int no=0; cout << "SomeObject() :" << (m_no=++no) << endl; }
    ~SomeObject() { cout << "~SomeObject():" << m_no << endl; }
    int m_no;
};

int main()
{
    {
        // sizeof(int) 바이트 사용
        boost::pool<> p( sizeof(int) );
        int* x = (int*)p.malloc();
        int* y = (int*)p.malloc();
        int* z = (int*)p.malloc();
        *x = 10;
        p.free(z); // 명시적 free

        // free 명시적안해도 알아서 해제됨
    }

    {
        // SomeObject 객체
        boost::object_pool<SomeObject> p;
        SomeObject* x = p.construct();
        SomeObject* y = p.construct();
        SomeObject* z = p.construct();
        p.destroy(y);// 명시적 해제

        // destroy 명시적으로 해제 안해도 알아서 됨.
    }

    return 0;
}

#include <avr/io.h>
#include<avr/interrupt.h> 
#define F_CPU 16000000UL // 사용하고 있는 크리스탈 주파수 값을 상수로 설정합니다.
#include <util/delay.h> // 지연 함수 관련 헤더파일을 포함합니다.
char rx_char(void) // 문자형 rx_char 수신 사용자 함수를 생성합니다.
{
// 문자 수신이 완료될 때까지 대기 UCSRA의 RXC가 비트1 이 되면 다음라인으로
while((UCSR0A&0x80) == 0);
return UDR0; // UDR 수신데이터 반환
}

void tx_char(char tx_data) // 문자형 tx_char 송신 사용자 함수를 생성합니다.
{
while((UCSR0A&0x20) == 0); // UDR레지스터가 빌 때까지 대기 UCSRA의 UDRE가 비트1 이 되면 다음라인으로
UDR0 = tx_data; // UDR레지스터에 입력한 tx_data 입력합니다.
}

int main(void) // 메인함수를 호출합니다.
{
char i, data; // 부호없는 문자형 변수 i, data를 생성합니다.

DDRB=0xFF; // B포트 8비트 전체를 출력으로 설정합니다.
PORTB=0x00; // B포트 8비트 전체의 초기값을 논리0 (0V)로 설정합니다.

UCSR0A=0x00; // UART설정 레지스터A 별도 설정 없음
UCSR0B=0x18; // UART설정 레지스터B RXEN과 TXEN을 비트1로 설정해서 송수신기능을 활성화 합니다.
UCSR0C=0x06; // UART설정 레지스터C UCSZ1과 UCSZ0을 비트1로 설정해서 8비트 데이터 전송으로 설정합니다.
//UBRR = 416;
int baud = 2400;
int ubrr= F_CPU/16/baud-1;

// 통신 속도 설정
UBRR0H = (unsigned char)(ubrr>>8); 
UBRR0L=(unsigned char)ubrr;

while(1) // 아래 구문을 무한 반복합니다.
{
tx_char('B');
_delay_ms(100);
/* data = rx_char(); // data 변수에 rx_char 사용자 함수사용으로 수신된 데이터를 저장합니다. */

/* if(data=='y') // data변수와 문자y가 같으면 */
/* { */
/* PORTB=0xFF; // B포트 전체 논리1 (5V)를 출력합니다. */
/* tx_char('_'); // tx_char 사용자 함수 사용으로 _문자를 송신합니다. */
/* tx_char('o'); // tx_char 사용자 함수 사용으로 o문자를 송신합니다. */
/* tx_char('k'); // tx_char 사용자 함수 사용으로 k문자를 송신합니다. */
/* } */
/* if(data=='n') // data변수와 문자n과 같으면 */
/* { */
/* PORTB=0x00; // B포트 전체 논리0 (0V)를 출력합니다. */
/* tx_char('_'); // tx_char 사용자 함수 사용으로 _문자를 송신합니다. */
/* tx_char('o'); // tx_char 사용자 함수 사용으로 o문자를 송신합니다. */
/* tx_char('k'); // tx_char 사용자 함수 사용으로 k문자를 송신합니다. */
/* } */
/* if(data=='b') // data변수와 문자b가 같으면 */
/* { */
/* for(i=0;i<3;i++) // 아래구문을 3번 반복합니다. */
/* { */
/* PORTB=0xFF; // B포트 전체 논리1 (5V)를 출력합니다. */
/* _delay_ms(200); // 위 상태를 0.2초 동안 유지합니다. */
/* PORTB=0x00; // B포트 전체 논리0 (0V)를 출력합니다. */
/* _delay_ms(200); // 위 상태를 0.2초 동안 유지합니다. */
/* } */
/* tx_char('_'); // tx_char 사용자 함수 사용으로 _문자를 송신합니다. */
/* tx_char('o'); // tx_char 사용자 함수 사용으로 o문자를 송신합니다. */
/* tx_char('k'); // tx_char 사용자 함수 사용으로 k문자를 송신합니다. */
/* } */
}

return 0; // 정상종료 값 0을 리턴합니다.
}

#include <avr/interrupt.h>
#include <avr/io.h>
void port_init(void)
{
    PORTA = 0x00;
    DDRA  = 0x00;
    PORTB = 0x00;
    DDRB  = 0x00;
    PORTC = 0x00; //m103 output only
    DDRC  = 0x00;
    PORTD = 0x00;
    DDRD  = 0x00;
    PORTE = 0x00;
    DDRE  = 0x00;
    PORTF = 0x00;
    DDRF  = 0x00;
    PORTG = 0x00;
    DDRG  = 0b00001111;
}


//call this routine to initialize all peripherals
void init_devices(void)
{
    //stop errant interrupts until set up
    cli(); //disable all interrupts
    XDIV  = 0x00; //xtal divider
    XMCRA = 0x00; //external memory
    port_init();


    MCUCR = 0x00;
    EICRA = 0x00; //extended ext ints
    EICRB = 0x00; //extended ext ints
    EIMSK = 0x00;
    TIMSK = 0x00; //timer interrupt sources
    ETIMSK = 0x00; //extended timer interrupt sources
    sei(); //re-enable interrupts
    //all peripherals are now initialized
}


void delay(int n)
{
    volatile int i,j;
    for(i=1;i<n;i++)
    {
        for(j=1;j<600;j++);
    }
}

int main(void)
{
    unsigned int temp, i;
    init_devices();    

    
    delay(600);
    
    while(1){
        if(PING & 0b00000100){
            PORTG = 0x01;
        }
        if(PING & 0b00001000){
    
            PORTG = 0x02;
        }
        delay(10);
    }
    return 0;
}

ㅇ.ㅇ

121.176.218.zzz149,43333 121.176.218.zzz149,43333