一般聲明systemC類模塊的格式為

SC_MODULE(類名）{
    端口聲明：  sc_in sc_out sc_inout
    在內部鏈接可能需要使用的信號    
    聲明需要使用的一般函數
    聲明需要使用的進程函數或者線程函數
    子模塊的聲明或者其指針的聲明
    數據變量的聲明
    //  構造函數
    SC_CTOR(類名）{
            註冊進程或者線程函數
            聲明敏感量列表
    }
}；

一旦函數在構造函數中進行了聲明，那麽這個函數就不再是一個簡單的方法了。

（1）在構造函數中使用SC_METHOD聲明：那麽這個一個進程方法，它會被敏感量所觸發。觸發後進入到函數執行，執行完畢後將執行權轉交給仿真內核。

進程方法必須是有限循環的。

（2）在構造函數中使用SC_THREAD聲明：那麽這是一個線程方法，它會被敏感量觸發。一般而言，觸發後會停止線程方法的掛起狀態，從而繼續執行，直

到遇 到下一個wait語句從而再次掛起。線程函數一般是無限循環的。

接下來博主就舉組合邏輯的例子-----關於數據選擇器multiplexer的建模：

base.h:

#ifndef BASE 
#define BASE 
 
#include "systemc.h" 
#include <iostream> 
#endif

simulus.h:

#include "base.h" 
 
#ifndef SIMULUS 
#define SIMULUS 
 
SC_MODULE(simulus){ 
    //   signal drivers  
    sc_out<bool>  cs ; 
    sc_out<sc_uint<3> > select ; 
     
     
    void prc_simulus(); 
     
    SC_CTOR(simulus){ 
        SC_THREAD(prc_simulus);    //  因為信號需要不斷的生成，所以需要使用THREAD線程方法
    } 
}; 
 
#endif

stimulus.cpp:

#include "simulus.h"
void simulus::prc_simulus(){
    //  signal generates process
    sc_uint<3> temp(0) ;
    
    cs = 0 ;
    
    for(;;){
        select = temp ;
        temp++ ;
        wait(10,SC_NS);      每次使線程掛起10ns
    }
}

monitor.h:

#include "base.h" 
 
#ifndef MONITOR 
#define MONITOR 
 
SC_MODULE(monitor){ 
    sc_in<bool> cs ; 
    sc_in<sc_uint<3> > select ; 
    sc_in<sc_uint<8> > mul_out; 
     
    void prc_monitor(); 
     
    SC_CTOR(monitor){ 
        SC_METHOD(prc_monitor); 
        sensitive<<mul_out;               //  輸出監視，監視multiplexer的輸出
    }; 
}; 
 
#endif

monitor.cpp:

#include "monitor.h"
void monitor::prc_monitor(){
    //    在這個輸出中無法使用c語言的函數進行輸出，因為類型無法匹配，
    //    並且systemc2.x 的版本較老了，沒有辦法使用其內建的to_string函數
    cout<<cs.read()<<" "<<select.read()<<" "<<mul_out.read()<<std::endl ;
}

dut.h(Design under test ----- multiplexer ):

#include "../base.h" 
 
#ifndef DUT 
#define DUT 
 
SC_MODULE(multiplexer){ 
     
     
    sc_in<bool> cs_n ; 
    sc_in<sc_uint<3> >select ; 
    sc_out<sc_uint<8> >  mul_out ; 
     
    void prc_mul(); 
     
    SC_CTOR(multiplexer){ 
        SC_METHOD(prc_mul); 
        sensitive<<cs_n<<select ; 
    }; 
     
}; 
 
#endif

dut.cpp:

#include "dut.h"
void multiplexer::prc_mul()        //  數據選擇器的內部邏輯實現
{
    sc_uint<8> temp = 0 ;
    temp = ~temp ;
    if( cs_n )
        mul_out = temp ;
    else {
        temp[select.read()] = 0 ;
        mul_out = temp ;
    }
}

最後的總測試文件main.cpp:

#include "simulus.h"
#include "dut/dut.h"
#include "monitor.h"
int sc_main(int argc , char * argv[]){
    //    signal defination
    sc_signal<sc_uint<3> > select_sig;
    sc_signal<sc_uint<8> > mul_out_sig;
    sc_signal<bool> cs_sig ;
    
    sc_trace_file * vcd = sc_create_vcd_trace_file("record");     //  創立一個vcd記錄文件
    
    //  istance the component
    simulus sim("select");
    sim(cs_sig,select_sig);
    
    multiplexer mul("multiplexer");
    mul(cs_sig,select_sig,mul_out_sig);
    
    monitor mon("monitor");
    mon(cs_sig,select_sig,mul_out_sig);
    
    sc_trace(vcd,select_sig,"select");
    sc_trace(vcd,mul_out_sig,"multiplexer");    //   將需要記錄的文件加入到vcd文件中
    sc_start(1000,SC_NS);        //   仿真時間為1000ns
    
    sc_close_vcd_trace_file(vcd);               //    仿真結束後關閉vcd文件
    return 0 ;
}

最後的仿真結果：

systemC的組合邏輯建模