Wie eine std::mutex in einem Kontext einer Klasse

ich habe einige Schwierigkeiten mit einer C++11 std::mutex

in meiner Klasse habe ich eine variable namens semaphore vom Typ std::mutex.

So, ich positionierte meine semaphore.lock() und semaphore.unlock() vor und nach meiner kritischen Abschnitt

class Database {
public:
Database(string, string, string, string);
virtual ~Database();

struct sMyHome getMyHome(void);
struct sPhysical getPhysical(int);
struct sSystemInfo getSystemInfo(void);
void commitSystemInfo(struct sSystemInfo);
struct sTSensors getTSensors(int);
struct sWireless getWireless(int);
struct sWirelessConf getWirelessConf(int);
struct sWirelessStatus getWirelessStatus(int);

private:
void queryMyHome(void);
void queryPhysical(int);
void querySystemInfo(void);
void queryTSensors(int ID);
void queryWireless(int ID);
void queryWirelessConf(int ID);
void queryWirelessStatus(int ID);
string toString(int);

struct sMyHome MyHome;
struct sPhysical Physical[4];
struct sSystemInfo SystemInfo;
struct sTSensors TSensors[32];
struct sWireless Wireless[64];
struct sWirelessConf WirelessConf[64];
struct sWirelessStatus WirelessStatus[64];

MYSQL *connection;
mutex semaphore;
};

dies ist Teil der main, wo bekomme ich die Fehlermeldung:

 Database db = Database("192.168.1.10", "****", "******", "******");

aber der cross-compiler, sagt 

../main.cpp:8:73: error: use of deleted function 'Database::Database(const Database&)'
  Database db = Database("192.168.1.10", "root", "raspberry", "DomoHome2");
                                                                     ^
In file included from ../main.cpp:2:0:
../Database.h:79:7: note: 'Database::Database(const Database&)' is implicitly deleted      because the default definition would be ill-formed:
 class Database {
   ^
../Database.h:79:7: error: use of deleted function 'std::mutex::mutex(const std::mutex&)'
 In file included from ../Database.h:12:0,
             from ../main.cpp:2:
/Volumes/rpi-crosscompiler-toolchain/arm-none-linux-gnueabi/arm-none-linux-gnueabi/include/c++/4.8.2/mutex:128:5: error: declared here
 mutex(const mutex&) = delete;
 ^
make: *** [main.o] Error 1

und das ist mein Konstruktor:

Database::Database(string Address, string Username, string Password, string Database) {
//TODO Auto-generated constructor stub
connection = mysql_init(NULL);
mysql_real_connect(connection, Address.c_str(), Username.c_str(), Password.c_str(), Database.c_str(), 0, NULL, 0);
}
Sie versuchen zu kopieren Database Objekt, aber es ist nicht kopierbar. Wahrscheinlich, weil es hat eine mutex Daten Mitglied. Ich kann nicht sehen, warum die mutex sollte statisch sein, BTW.
Sie sind sich nicht genügend von Ihrem code. Die Fehlermeldungen sind schwer zu interpretieren, es sei denn, Sie bieten mehr code.
Sie sind nicht zeigt den relevanten code, und das ist ein problem in Ihr "code" (check this one). Aber trotzdem prüfen die verschiedenen auto-lock Funktionen von Standard zu sperren/entsperren Synchronisierung Elemente.
Hinzugefügt mehr code, hoffe, dass dies helfen, die situation zu klären
Aufrufen einer std::mutex semaphore macht es nicht. Ich würde dir empfehlen einen anderen Namen verwenden, im Falle dass eines Tages können Sie einen aktuellen semaphore zu Ihrem Programm, und jemand ruft völlig verwirrt...

InformationsquelleAutor Angelo Cassano | 2014-06-17

  1. 13

    std::mutex ist weder kopierbar noch verschiebbar. Darunter einer, der in Ihre Klasse erfordert, dass Ihre Klasse wird nicht kopierbar (bewegliche) gut. Wenn Sie möchten, dass Ihre Klasse zu sein, kopierbar oder verschiebbar, Sie sagen dem compiler, wie die Objekte der Klasse kopiert oder verschoben durch die Implementierung kopieren/verschieben-Bau/Auftrag selbst. Zum Beispiel:

    class synchronized_int {
  mutable std::mutex mtx;
  int value;
public:
  synchronized_int(int v = 0) : value(v) {}

  //Move initialization
  synchronized_int(synchronized_int&& other) {
    std::lock_guard<std::mutex> lock(other.mtx);
    value = std::move(other.value);
    other.value = 0;
  }

  //Copy initialization
  synchronized_int(const synchronized_int& other) {
    std::lock_guard<std::mutex> lock(other.mtx);
    value = other.value;
  }

  //Move assignment
  synchronized_int& operator = (synchronized_int&& other) {
    std::lock(mtx, other.mtx);
    std::lock_guard<std::mutex> self_lock(mtx, std::adopt_lock);
    std::lock_guard<std::mutex> other_lock(other.mtx, std::adopt_lock);
    value = std::move(other.value);
    other.value = 0;
    return *this;
  }

  //Copy assignment
  synchronized_int& operator = (const synchronized_int& other) {
    std::lock(mtx, other.mtx);
    std::lock_guard<std::mutex> self_lock(mtx, std::adopt_lock);
    std::lock_guard<std::mutex> other_lock(other.mtx, std::adopt_lock);
    value = other.value;
    return *this;
  }
};
    Würden Sie bitte das kommentieren ein wenig auf was alles, was Sie tun, auf das Verschieben - /Kopieren-Zuordnung? Ich würde gedacht haben, dass nur zwei lock_guards Aussagen auf Ihre eigenen ausreichen würde-- es sieht aus, wie wenn Sie sperren beide von Ihnen mit lock und dann gehen die Schlösser zu lock_guard, vermutlich damit Sie automatisch frei, am Ende des Bereichs. Ich bin nur neugierig, warum Sie es auf diese Weise.
    Wenn eine Multithread-Programm-Blöcke warten auf mutex Eine Weile halten mutex B, es läuft Gefahr, in der Sackgasse: wenn ein anderer thread hält mutex-B und gleichzeitig blockiert das warten auf Ein mutex, thread weder jemals aufwachen und machen Fortschritte wieder. Die standard-Bibliothek bietet std::lock als ein Werkzeug zum arretieren mehreren Schlössern, während die Vermeidung von deadlock. Die Analyse der restliche code ist richtig: sobald std::lock gesperrt hat zwei Mutexe, ich habe lock_guards verabschieden, jedes mutex, so dass Sie ordnungsgemäß freigeschaltet werden, beim verlassen des Bereichs.

    InformationsquelleAutor Casey

  2. 1

    Erklären mutex dynamisch und nicht statisch.

    In Ihrer Datenbank header-Klasse deklarieren Sie die mutex-wie ein Zeiger, wie:

    mutex * semaphore;

    und in Ihrem Konstruktor initialisiert das mutex Aufruf seines Konstruktors:

    semaphore = new std::mutex();

    InformationsquelleAutor Derzu

Schreibe einen Kommentar