卷积交织/解交织C++程序

交织基数为M,交织深度为I的卷积交织/解交织程序，延时为I*(I-1)*M.

 #include <iostream>
 #include <vector>
 #include <list>
 #include <cstdint>

 using namespace std;

 vector<uint8_t> interleaving(vector<uint8_t> &sym_din, size_t M, size_t I)
 {
     list<uint8_t> sym_fifo[I];
     vector<uint8_t> sym_itlv;

     // Initialize Data FiFo
     for(size_t i = ; i < I; ++i) {
         for(size_t j = ; j < M*i; ++j)
             sym_fifo[i].push_back(uint8_t());
     }

     // Interleaving
     for(size_t i = ; i < sym_din.size(); ++i) {
         sym_fifo[size_t(i%I)].push_back(sym_din[i]);
         sym_itlv.push_back(sym_fifo[i%I].front());
         sym_fifo[i%I].pop_front();
     }

     return sym_itlv;
 }

 vector<uint8_t> deinterleaving_fifo(vector<uint8_t> &sym_din, size_t M, size_t I)
 {
     list<uint8_t> sym_fifo[I];
     vector<uint8_t> sym_itlv;

     // Initialize Data FiFo
     for(size_t i = ; i < I; ++i) {
         for(size_t j = ; j < M*(I -  - i); ++j)
             sym_fifo[i].push_back(uint8_t());
     }

     // DeInterleaving
     for(size_t i = ; i < sym_din.size(); ++i) {
         sym_fifo[size_t(i%I)].push_back(sym_din[i]);
         sym_itlv.push_back(sym_fifo[i%I].front());
         sym_fifo[i%I].pop_front();
     }

     // DeInterleaving Delay Should be I*(I-1)*M
     return sym_itlv;
 }

 vector<uint8_t> deinterleaving(vector<uint8_t> &sym_din, size_t M, size_t I)
 {
     size_t branch = ;
     size_t wraddr = ;
     size_t rdaddr = (I - ) * M;
     vector<uint8_t> sym_ram(I*(I-)*M/+);
     vector<uint8_t> sym_itlv;

     // Initialize Data RAM
     for(size_t i = ; i < I*(I-)*M/ + ; ++i) {
         sym_ram[i] = uint8_t();
     }

     // DeInterleaving
     for(size_t i = ; i < sym_din.size(); ++i) {
         branch = i % I;

         sym_ram[wraddr] = sym_din[i];
         wraddr = wraddr + (I-)*M - branch * M;
         wraddr = wraddr >= (I*(I-)*M/ + ) ? wraddr - (I*(I-)*M/ + ) : wraddr;

         sym_itlv.push_back(sym_ram[rdaddr]);
         rdaddr = rdaddr + (I-)*M - ((branch + ) % I) * M;
         rdaddr = rdaddr >= (I*(I-)*M/ + ) ? rdaddr - (I*(I-)*M/ + ) : rdaddr;
     }

     // DeInterleaving Delay Should be I*(I-1)*M
     return sym_itlv;
 }

 int main(int argc, char **argv)
 {
     size_t deint_delay = ;
     vector<uint8_t> sym_din;
     vector<uint8_t> sym_itlv;
     vector<uint8_t> sym_deitlv;

     for(size_t i = ; i < ***; ++i)
         sym_din.push_back(i+);

     sym_itlv = interleaving(sym_din, , );
     sym_deitlv = deinterleaving(sym_itlv, , );

     cout << "Interleaving:" << endl;
     for(vector<uint8_t>::iterator itr = sym_itlv.begin(); itr != sym_itlv.end(); ++itr) {
         cout << int(*itr) << ' ' << flush;
     }
     cout << endl;

     cout << "DeInterleaving:" << endl;

     for(vector<uint8_t>::iterator itr = sym_deitlv.begin(); itr != sym_deitlv.end(); ++itr) {
         cout << int(*itr) << ' ' << flush;
         if(*itr ==  && deint_delay == )
             deint_delay = itr - sym_deitlv.begin();
     }
     cout << endl;
     cout << "Deint Delay is " << deint_delay << endl;

     return ;
 }