Object Oriented Design - The easiest case, but I'm confused anyway!

Question

When I wrap up some procedural code in a class (in my case c++, but that is probably not of interest here) I'm often confused about the best way to do it. With procedural code I mean something that you could easily put in an procedure and where you use the surrounding object mainly for clarity and ease of use (error handling, logging, transaction handling...).

For example, I want to write some code, that reads stuff from the database, does some calculations on it and makes some changes to the database. For being able to do this, it needs data from the caller.

How does this data get into the object the best way. Let's assume that it needs 7 Values and a list of integers.

My ideas are:

• List of Parameters of the constructor
• Set Functions
• List of Parameters of the central function

Advantage of the first solution is that the caller has to deliver exactly what the class needs to do the job and ensures also that the data is available right after the class has been created. The object could then be stored somewhere and the central function could be triggered by the caller whenever he wants to without any further interaction with the object.

Its almost the same in the second example, but now the central function has to check if all necessary data has been delivered by the caller. And the question is if you have a single set function for every peace of data or if you have only one.

The Last solution has only the advantage, that the data has not to be stored before execution. But then it looks like a normal function call and the class approaches benefits disappear.

How do you do something like that? Are my considerations correct? I'm I missing some advantages/disadvantages?

This stuff is so simple but I couldn't find any resources on it.

Edit: I'm not talking about the database connection. I mean all the data need for the procedure to complete. For example all informations of a bookkeeping transaction.

Lets do a poll, what do you like more:

class WriteAdress {
  WriteAdress(string name, string street, string city);
  void Execute();
}

or

class WriteAdress {
  void Execute(string name, string street, string city);
}

or

class WriteAdress {
  void SetName(string Name);
  void SetStreet(string Street);
  void SetCity(string City);
  void Execute();
}

or

class WriteAdress {
  void SetData(string name, string street, string city);
  void Execute();
}

Answer 1

Values should be data members if they need to be used by more than one member function. So a database handle is a prime example: you open the connection to the database and get the handle, then you pass it in to several functions to operate on the database, and finally close it. Depending on your circumstances you may open it directly in the constructor and close it in the destructor, or just accept it as a value in the constructor and store it for later use by the member functions.

On the other hand, values that are only used by one member function and may vary every call should remain function parameters rather than constructor parameters. If they are always the same for every invocation of the function then make them constructor parameters, or just initialize them in the constructor.

Do not do two-stage construction. Requiring that you call a bunch of setXYZ functions on a class after the constructor before you can call a member function is a bad plan. Either make the necessary values initialized in the constructor (whether directly, or from constructor parameters), or take them as function parameters. Whether or not you provide setters which can change the values after construction is a different decision, but an object should always be usable immediately after construction.