Comment faire pour contourner le code C++ 11 non pris en charge

Question

Le compilateur de mon école ne semble pas prendre en charge C++ 11 mais je ne suis pas sûr de savoir comment contourner ce problème. Je ne suis pas sûr de ce qui cause la dernière erreur du compilateur. Je tente de compiler sous Linux avec:

gcc -std=c++0x project2.cpp 

Le système ne reconnaît pas -std = C++ 11. Des idées sur la façon de le compiler? Je vous remercie!

#include <thread> 
#include <cinttypes> 
#include <mutex> 
#include <iostream> 
#include <fstream> 
#include <string> 
#include "time_functions.h" 
using namespace std; 

#define RING_BUFFER_SIZE 10 
class lockled_ring_buffer_spsc 
{ 
private: 
    int write = 0; 
    int read = 0; 
    int size = RING_BUFFER_SIZE; 
    string buffer[RING_BUFFER_SIZE]; 
    std::mutex lock; 
public: 

    void push(string val) 
    { 
     lock.lock(); 
     buffer[write%size] = val; 
     write++; 
     lock.unlock(); 
    } 

    string pop() 
    { 
     lock.lock(); 
     string ret = buffer[read%size]; 
     read++; 
     lock.unlock(); 
     return ret; 
    } 
}; 

int main(int argc, char** argv) 
{ 
    lockled_ring_buffer_spsc queue; 

    std::thread write_thread([&]() { 
     start_timing(); 
     string line; 
     ifstream myfile("p2-in.txt"); 
     if (myfile.is_open()) 
     { 
      while (getline(myfile, line)) 
      { 
       line += "\n"; 
       queue.push(line); 
       cout << line << " in \n"; 
      } 
      queue.push("EOF"); 


      myfile.close(); 
      stop_timing(); 


     } 

    } 
    ); 
    std::thread read_thread([&]() { 
     ofstream myfile; 
     myfile.open("p2-out.txt", std::ofstream::out | std::ofstream::trunc); 
     myfile.clear(); 
     string tmp; 
     while (1) 
     { 

      if (myfile.is_open()) 
      { 
       tmp=queue.pop(); 

       cout << tmp << "out \n"; 
       if (tmp._Equal("EOF")) 
        break; 

       myfile << tmp; 
      } 
      else cout << "Unable to open file"; 
     } 
     stop_timing(); 
     myfile.close(); 
    } 
    ); 

    write_thread.join(); 
    read_thread.join(); 
    cout << "Wall clock diffs:" << get_wall_clock_diff() << "\n"; 
    cout << "CPU time diffs:" << get_CPU_time_diff() << "\n"; 

    system("pause"); 

    return 0; 
} 

Erreurs de compilation:

project2.cpp:14:14: sorry, unimplemented: non-static data member initializers 
project2.cpp:14:14: error: ISO C++ forbids in-class initialization of non-const static member ‘write’ 
project2.cpp:15:13: sorry, unimplemented: non-static data member initializers 
project2.cpp:15:13: error: ISO C++ forbids in-class initialization of non-const static member ‘read’ 
project2.cpp:16:13: sorry, unimplemented: non-static data member initializers 
project2.cpp:16:13: error: ISO C++ forbids in-class initialization of non-const static member ‘size’ 
project2.cpp: In lambda function: 
project2.cpp:79:13: error: ‘std::string’ has no member named ‘_Equal’ 

Answer 1

vous pouvez remplacer

class lockled_ring_buffer_spsc 
{ 
private: 
    int write = 0; 
    int read = 0; 
    int size = RING_BUFFER_SIZE; 
    string buffer[RING_BUFFER_SIZE]; 
    std::mutex lock; 
public: 

par les membres initialisés (à l'exception du tableau statique) + un constructeur par défaut

class lockled_ring_buffer_spsc 
{ 
private: 
    int write; 
    int read; 
    int size; 
    string buffer[RING_BUFFER_SIZE]; 
    //std::mutex lock; 
public: 
    lockled_ring_buffer_spsc() : write(0),read(0),size(RING_BUFFER_SIZE) 
    {} 

et

if (tmp._Equal("EOF")) 

est tout simplement

if (tmp == "EOF") 

Comme quelqu'un a noté, std::mutex seulement a été introduit en C++ 11. Vous devez utiliser C pthread_mutex_lock/pthread_mutex_unlock fonctions par exemple simple.

Answer 2

Il est étrange que votre compilateur ne se plaint pas de std::mutex, qui est une fonctionnalité C++ 11, mais se plaint des autres fonctionnalités de C++ 11.

Les lignes

int write = 0; 
int read = 0; 
int size = RING_BUFFER_SIZE; 

sont valables dans 11 mais pas les versions antérieures C +. Vous pouvez les initialiser dans un constructeur.

class lockled_ring_buffer_spsc 
{ 
private: 
    int write; 
    int read; 
    int size; 
    string buffer[RING_BUFFER_SIZE]; 
    std::mutex lock; 
public: 
    lockled_ring_buffer_spsc() : write(0), read(0), size(RING_BUFFER_SIZE) {} 

... 

}; 

qui fonctionnera aussi longtemps que le compilateur prend en charge std::mutex dans une version pré-C 11. Si ce n'est pas le cas, vous devrez trouver une solution à ce problème séparément.