Is this C ++ code exception thrown out?

Question

I have the following code from mysql.com :

/* Copyright 2008, 2010, Oracle and/or its affiliates. All rights reserved.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.

There are special exceptions to the terms and conditions of the GPL
as it is applied to this software. View the full text of the
exception in file EXCEPTIONS-CONNECTOR-C++ in the directory of this
software distribution.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

/* Standard C++ includes */
#include <stdlib.h>
#include <iostream>

/*
  Include directly the different
  headers from cppconn/ and mysql_driver.h + mysql_util.h
  (and mysql_connection.h). This will reduce your build time!
*/
#include "mysql_connection.h"

#include <cppconn/driver.h>
#include <cppconn/exception.h>
#include <cppconn/resultset.h>
#include <cppconn/statement.h>

using namespace std;

int main(void)
{
cout << endl;
cout << "Running 'SELECT 'Hello World!' AS _message'..." << endl;

try {
  sql::Driver *driver;
  sql::Connection *con;
  sql::Statement *stmt;
  sql::ResultSet *res;

  /* Create a connection */
  driver = get_driver_instance();
  con = driver->connect("tcp://127.0.0.1:3306", "root", "root");
  /* Connect to the MySQL test database */
  con->setSchema("test");

  stmt = con->createStatement();
  res = stmt->executeQuery("SELECT 'Hello World!' AS _message");
  while (res->next()) {
    cout << "\t... MySQL replies: ";
    /* Access column data by alias or column name */
    cout << res->getString("_message") << endl;
    cout << "\t... MySQL says it again: ";
    /* Access column data by numeric offset, 1 is the first column */
    cout << res->getString(1) << endl;
  }
  delete res;
  delete stmt;
  delete con;

} catch (sql::SQLException &e) {
  cout << "# ERR: SQLException in " << __FILE__;
  cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
  cout << "# ERR: " << e.what();
  cout << " (MySQL error code: " << e.getErrorCode();
  cout << ", SQLState: " << e.getSQLState() << " )" << endl;
}

cout << endl;

return EXIT_SUCCESS;
}

I always thought that such code is not safe, because the instructions are deletenot executed in case of an exception and, therefore, unique_ptror some other kind of smart pointers. But since this is an official code sample, I'm not sure about that. So:

Is the safe exception of the example above?

Answer 1

Is the safe exception of the example above?

H ** l no!

It is exactly the same as you say. The code you see as a leak, as a sieve after exceptions.

RAII or pointers should be used std::unique.

Even for pre-standard C ++ code, there was a good ole std::auto_ptr.

---

, .

, Open Source - "", - "", , .

.

---

, ( MySQL):

, , main() , .

. , "CTRL-C CTRL-V codez ", , .

---

Conclusio:

, , , .

.

, .

---

, :

(. ) -:

class MySQLQuery;

class MySQLConnection {
    std::function<void(void*)> driverCleanup_;
    std::function<void>(void*) connectionCleanup_;
    std::unique_ptr<sql::Driver> driver_;
    std::shared_ptr<sql::Connection> con_;
public:
    MySQLConnection
        ( const std::string& ipAddress
        , const std::string& user
        , const std::string& password
        ) : 
        driverCleanup_([](void *driver) {
          // (sql::Driver*)driver->cleanup(); ## Whatever necessary
          delete driver;
        }) ,
        connectionCleanup_([](void *connection) {
          // (sql::Connection*)connection->cleanup();
          delete connection;
        }),
        driver_(get_driver_instance(),driverCleanup_),
        con_(std::make_shared(driver_->connect(ipAddress,user,password)
                             ,connectionCleanup_))
    {}

    std::unique_ptr<MySQLQuery> CreateQuery(const std::string& query);
};

---

class MySQLQuery {
     friend class MySQLConnection;

     std::shared_ptr<sql::Connection> con_;
     std::unique_ptr<sql::Statement stmt_;
     MySQLQuery
       ( std::shared_ptr<sql::Connection> connection
       , const std::string& query
       ) : con_(connection) 
         , stmt_(con_->createStatement()
     {
     }
public:
     // And so on ...
     MySQLResultSet Execute() {
        return stmt_->executeQuery("SELECT 'Hello World!' AS _message");
     }
};

---

std::unique_ptr<MySQLQuery> MySQLConnection::CreateQuery(const std::string& query) 
{
    return std::make_unique<MySQLQuery>(con_,query);
}

, . * ( ) . .

, , .