C++ pqxx classes de connexion discrètes postgresql, pointeur de classe de portée

Question

J'ai une classe, DBProc, qui établit une connexion à PostgreSQL et permet à l'utilisateur de soumettre des requêtes/récupérer des résultats.

Fonctionnellement, tout fonctionne.

La fonction DBProc :: connect() prend un argument facultatif pour le type de connexion. Les 3 variantes sont: directe, paresseuse, asynchrone.

J'ai un code qui instancie la classe de connexion correcte selon le choix de l'utilisateur. J'initialise 3 unique_ptr <> à l'avance, un pour chaque classe de connexion possible, puis utilise une instruction switch pour choisir le type de classe sélectionné.

Tout cela fonctionne très bien ... mais

Ma préférence serait d'avoir une classe var qui contient une référence à la classe de connexion

(toutes les classes ont la même fonctionnalité exacte) , mais je ne vois pas de moyen facile de le faire. 'auto & currentConnection = lazyConnection' fonctionne très bien dans l'instruction switch, mais bien sûr, sort de la portée après le bloc de code.

S'il existait un moyen de créer un var dans un bloc et de le laisser voir en dehors du bloc, sans le déclarer, ça marcherait, mais je ne crois pas que ce soit possible en C++.

Je ne peux pas le déclarer en premier car toutes ces classes nécessitent une initialisation lors de la déclaration. Donc ... C++ atch 22 ;-)

Donc, chaque fois que j'ai besoin d'utiliser la connexion, j'ai besoin d'une instruction switch pour sélectionner le bon pointeur.

J'ai regardé des modèles, unions, extern, et ne vois pas un moyen de le faire avec l'un de ceux-ci.

Si quelqu'un sait s'il existe un moyen de le faire, veuillez décrire.

Voici un extrait de code de classe func:

bool DBProc::connect(ConnectionType type) { 

... 

unique_ptr<pqxx::connection> connect; 
unique_ptr<pqxx::lazyconnection> lzy_connect; 
unique_ptr<pqxx::asyncconnection> async_connect; 

try 
{ 
    switch (type) { 
     case ConnectionType::direct : { 
      connect = make_unique<pqxx::connection>(connOpts); 
      break; 
     } 
     case ConnectionType::lazy : { 
      lzy_connect = make_unique<pqxx::lazyconnection>(connOpts); 
      break; 
     } 
     case ConnectionType::async : { 
      async_connect = make_unique<pqxx::asyncconnection>(connOpts); 
      break; 
     } 
} catch 
    ... 
} 

Answer 1

réponse travail fourni dans le commentaire par 'un mec programmeur'

Pourquoi ne pas avoir un std :: unique_ptr à pqxx :: connection_base qui est la classe de base commune pour tous les types de connexion? - Certains programmeur mec

Code simplifié:

unique_ptr<pqxx::connection_base> base_connect; 

try 
{ 
    switch (type) { 
     case ConnectionType::direct : { 
      base_connect = make_unique<pqxx::connection>(connOpts); 
      break; 
     } 
     case ConnectionType::lazy : { 
      base_connect = make_unique<pqxx::lazyconnection>(connOpts); 
      break; 
     } 
     case ConnectionType::async : { 
      base_connect = make_unique<pqxx::asyncconnection>(connOpts); 
      break; 
     } 
     default: 
      error += "No valid connection type supplied (direct | lazy | async)"; 
      return false; 
      break; 
    }