Question

我试图在C++;

中声明一个常量变量

        #include <iostream>
        #include <pthread.h>
        #include <stdlib.h>

        using namespace std;

        //
        // declare the mutex
        //
        static pthread_mutex_t mutex    = PTHREAD_MUTEX_INITIALIZER;

        //
        // AVOID NEGATIVE NUMBERS
        //
        unsigned int MAXSIZE = 0;
        unsigned int head = 0;
        unsigned int tail = 0;  

        //
        // return a empty circular queue
        //
        int* initialize(int size){

           MAXSIZE = size;
           pthread_mutex_lock( &mutex );
           int* queue = new int[ MAXSIZE ];
           // initialize each position to zero ( explicitly )
           for(int i = 0; i < MAXSIZE; i++){
            queue[i] = 0;
           } 

           pthread_mutex_unlock( &mutex );
           return queue;
        }

        //
        // enqueue number into the queue
        // returns the position it was stored
        //
        void* enqueue( void* local_queue, void* local_data ){
           // ASSERT ONLY ONE THREAD EACH  TIME
           pthread_mutex_lock( &mutex );
           // convert back to int
           int data = *((int*)(&local_data));
           int* queue = (int*)local_queue;

           queue[tail] = data;
           tail = (tail+1) % MAXSIZE;

           pthread_mutex_unlock( &mutex );
           cout << "Tail: " << tail << endl;
        }

        //
        // dequeue, given the queue
        //
        void* dequeue( void* queue ){
           int temp;
           pthread_mutex_lock( &mutex );
           int* local_queue = ( int* )queue; 
           temp = local_queue[ head ];
           head = ( head + 1 ) % MAXSIZE;

           pthread_mutex_unlock( &mutex );
           cout << "Removed: " << temp << endl;
    }

    // 
    // print the queue as it is
    //
    void* display( void* local_queue ){
       pthread_mutex_lock( &mutex );
       int* queue = (int*)local_queue;
       if( head == tail ){
        cout << "Queue underflow" << endl;
       }
       else{
        //
        // prints each element in the queue
        //
        for( unsigned int i = head; i < tail; i = (i+1) % MAXSIZE ){
            cout << queue[i] << endl;
        }
       }
       pthread_mutex_unlock( &mutex );
    }

    //
    // delete the memory allocated to the queue
    //
    void remove( int* queue){
       delete queue;
    }

    //
    // explain the user how to run the program
    //
    void usage(){
      cout << "Usage: " << endl; 
      cout << "    ./queue [size] [elements]" << endl;
      cout << "ex: ./queue 5 0 1 2 3 4 5" << endl;
    }

    //
    // main function, the tests are done in the for loop
    //
    int main( int argc, char* argv[] ){

       pthread_t threads[5];

       if(argc < 2){
        cout << "Args must be at least 1 " << endl;
        usage();
        return -1;
       }

       for(size_t j = 0; j < 5; j++){   
        unsigned int size = atoi( argv[1] );
        cout << "Size: " << size << endl;
        int* queue = initialize(size);

        for(size_t i = 2; i < argc; i++){
            enqueue( queue, (void*)atoi( argv[i] ) );
        }
            pthread_create( &threads[j], NULL, dequeue, (void*)queue );
        // make sure memory is freed 
        // finally end the thread
        pthread_join( threads[j], NULL );
        remove(queue);
       }
       return 0;
    }

我希望unsigned int MAXSIZE = 0;声明为const unsigned int MAXSIZE;所以我可以在runtime初始化它。我知道它可以在class的构造函数中完成，但我想知道是否有一种方法可以将MAXSIZE初始化为size由用户提供。 MAXSIZE用于实现在数组中实现的循环队列，因此将MAXSIZE声明为const以避免被更改然后影响{circular非常重要{1}}队列的操作。谢谢。 * 我希望我能够澄清我的问题，以便得到更准确的答案。为了完整性和社区的缘故，我已将所有代码添加到问题中。 *

Answer 1

在运行时初始化const变量的唯一方法是它是否是类的成员。然后，您可以使用构造函数的初始化列表来设置初始值。

Answer 2

AFAIK，你只能在声明它们时初始化const变量。

在您的代码中，为什么不使用参数size？

int* initialize(const unsigned int size){

   pthread_mutex_lock( &mutex );
   // MAXSIZE = size;
   int* queue = new int[ size];
   // initialize each position to zero ( explicitly )
   for(int i = 0; i < size; i++){
        queue[i] = 0;
   }

   pthread_mutex_unlock( &mutex );
   return queue;
}

传递const作为参数的全部目的是确保它不会在函数内部进行更改。

Answer 3

如果必须在运行时“初始化”变量，则它不是常量变量。只是让它不稳定而忘记这个问题。

Answer 4

只需使用：

const unsigned int MAXSIZE = 1000;

声明后：

extern const unsigned int MAXSIZE;  // THIS is a declaration
const unsigned int MAXSIZE = 1000;

问题是，const unsigned int MAXSIZE 不是声明，而是定义并执行初始化。

Answer 5

在C ++ 11中，您可以做到

const extern int i; // declare in *.h file

const int i = [](){ // init
     return 10;
}();

在声明C ++之后初始化const变量

5 个答案: