cl_my_rand.cpp

完美随机数的实现 , 以类封装随机数的实现 , 随机数的产生不会出现重复 , 程序只是简单实现 , 有待改进 .

//  ______________________   完美随机数    __________________________________  //

# ifndef   _MY_RAND_NUM_
# define   _MY_RAND_NUM_
# include<ctime>
# include<cstdlib>
# include<iostream>
# include<cmath>

using namespace std ;

enum Status { FAIL = -1 , OK = 0 , ERR = 1 };

class cl_my_rand 
{
      //   私有成员变量 
private:
        int min_num;      //   随机数序列的最小数 
        int max_num;      //   随机数序列的最大数 
        int num_num;      //   随机数序列的数的总个数 
        int loc_num;      //   随机数序列的当前随机数的位置 
        int *buf_num;     //   随机数序列的存放缓冲 

public:

        
public:          //        公有函数和方法 
       cl_my_rand(){
                    min_num = 0 ;
                    max_num = 0 ;
                    num_num = 0 ;
                    loc_num = 0 ;
                    } ;     
       cl_my_rand( int min , int max );
       
       ~cl_my_rand(){
              free( buf_num ) ;
              min_num = 0 ;
              max_num = 0 ;
              num_num = 0 ;
              loc_num = 0 ; };
              
       Status Instance( int min , int max );       //      初始化随机数实例 
       Status Instance();
       Status ReInstance();                        //      重新初始化随机数序列 
       int GetMin(){ return  min_num ; };          //       获得最小的数字,下同 
       void Get_Min( int & min ) { min = min_num ; } ;
       int GetMax(){ return  max_num ; } ;         //       获得最大随机数,下同 
       void Get_Max( int & max ){ max = max_num ; };
       int GetLength(){ return num_num ; } ;         //       获得随机数序列的长度 
       void Get_length( int & len ){ len = num_num ; };
       int Rand();                                 //        产生随机数 
       void Rand( int & num );                     //        同上   

     
       
       
       
private:          //   私有成员函数       
      
      Status InitNum();          //         初始化缓冲区 
      void ChangeNum();        //          随机交换缓冲区序列产生随机数 
      
 

};

cl_my_rand::cl_my_rand( int min , int max )
{
        //     初始化基本私有变量 
        min_num = min ;
        max_num = max ;
        num_num = max - min + 1 ;
        (num_num > 0 ) ? loc_num = 0 : loc_num = -1 ;
        Instance() ;
        
}

Status cl_my_rand::Instance( )
{

       if( InitNum() != OK ) return FAIL;
       ChangeNum();
       return OK;
}

Status cl_my_rand::Instance( int min , int max )
{
       min_num = min ;
       max_num = max ;
       num_num = max - min + 1 ;
       ( num_num > 0 ) ? loc_num = 0 : loc_num = -1 ;
       Instance();
}       

Status cl_my_rand::InitNum()
{
       if( num_num == 0 ) return FAIL;
       if( min_num >= max_num ) return ERR;
       if( NULL == (
                     buf_num = ( 
                              (int *)malloc ( num_num * sizeof ( int ) )
                             )
                    )
          ) return FAIL ;
        for( int i = 0 ; i < num_num ; i = i + 1 )
        {
             buf_num[i] = min_num + i ;
        }
        return OK;
}

void cl_my_rand::ChangeNum()
{
       int old_rand = 0 , new_rand = 0 ;
       int temp = 0 ;
       srand( time( NULL ));
       new_rand = abs(rand() % num_num) ;       //  将随机交换的位置控制在序列个数之内 
       for( int i = 0 ; i < ( num_num * 4 ) ; i++ )          //     做序列个数次随机交换 
       {
            old_rand = new_rand ;      //    提高随机数的使用率（测试中） 
            new_rand = abs(rand() % num_num) ;
            temp = buf_num[old_rand];
            buf_num[old_rand] = buf_num[new_rand];
            buf_num[new_rand] = temp ;
       }    
}       

          
int cl_my_rand::Rand()                                 //        产生随机数 
{
    if( loc_num == -1 )
        return 0;
    else 
    {
         loc_num = loc_num + 1 ;
         return buf_num[loc_num - 1 ];
    }    
}


void cl_my_rand::Rand( int & num )                     //        同上   
{
    if( loc_num == -1 )
    {
        num = 0 ;
        return ;
    }
    num = buf_num[loc_num];
    loc_num = loc_num + 1;     
}




           

# endif   //   _MY_RAND_NUM_