Initializing without assigning

[Calle Pettersson]

Coming from writing mostly in Java, I have trouble understanding how to
declare a member without initializing it, and do that later... In Java,
I would write something like
public static void main(String[] args) {
MyType aMember;
...
aMember = new MyType(...)
...
}
However, in C++ this does not seem to work. I declare in class (it's
for serial port communication) like this:

#include <fstream>
#include <boost/thread/thread.hpp>

class COMConn {
public:
COMConn(int port);
~COMConn();

char *send(char);
char *send(char, char[]);
private:
void connect(int);

std::ifstream input;
std::ofstream output;

boost::thread inputthread;
boost::thread outputthread;
};

But when I want to initialize the threads and streams, I want to do
something like

void COMConn::connec t(int port) {
this->input = std::ifstream(" COM1:");
this->inputthread = boost::thread(& input.read); // Not correct, needs
arguments, but skip that for now
//etc for the others
}

How do you go about doing this in C++? I found that I could do
this->input.open("CO M1:");
But that is hardly something that will work in general. I find this
very confusing I must say... Thanks you for any advice

[Michiel.Salters]

Calle Pettersson wrote:

Coming from writing mostly in Java, I have trouble understanding how to
declare a member without initializing it, and do that later...

General rule: don't. Just move the declaration to the point where you
initialize it, as any object is unusable until initialized.

You don't have to declare variables first; that's a old C habit which
is not
even needed in today's C, let alone in newer languages.

HTH
Michiel Salters

[Calle Pettersson]

Mi************* @tomtom.com wrote:

Calle Pettersson wrote:

Coming from writing mostly in Java, I have trouble understanding how to
declare a member without initializing it, and do that later...

General rule: don't. Just move the declaration to the point where you
initialize it, as any object is unusable until initialized.

You don't have to declare variables first; that's a old C habit which
is not
even needed in today's C, let alone in newer languages.

HTH
Michiel Salters

Really? But if I need this to be accessible to the class, but can't
call the constructor in the class definition? (Need to know which com
port in this case)
Also, I didn't know that variables could be added to a class if they
aren't specified in the header?
Or am I misunderstandin g you?

[Victor Bazarov]

Calle Pettersson wrote:

Mi************* @tomtom.com wrote:

>Calle Pettersson wrote:

>>Coming from writing mostly in Java, I have trouble understanding
how to declare a member without initializing it, and do that
later...

General rule: don't. Just move the declaration to the point where you
initialize it, as any object is unusable until initialized.

You don't have to declare variables first; that's a old C habit which
is not
even needed in today's C, let alone in newer languages.

HTH
Michiel Salters

Really? But if I need this to be accessible to the class, but can't
call the constructor in the class definition? (Need to know which com
port in this case)
Also, I didn't know that variables could be added to a class if they
aren't specified in the header?
Or am I misunderstandin g you?

It seems you're misunderstandin g each other.

*Members* are declared first, in the class definition. Then, in the
initialiser list of a constructor, they are initialised. *Variables*
(non-member, stand-alone) don't need to be declared. Declare/define/
initialise them when needed.

class Class {
void *member; // a member: declaration
public:
Class() : member(0) {} // initialisation
};

int main() {
void *nonmember(0); // a variable: declaration/definition/init'n
}
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Thomas J. Gritzan]

Calle Pettersson schrieb:

#include <fstream>
#include <boost/thread/thread.hpp>

class COMConn {
public:
COMConn(int port);
~COMConn();

char *send(char);
char *send(char, char[]);
private:
void connect(int);

std::ifstream input;
std::ofstream output;

boost::thread inputthread;
boost::thread outputthread;
};

But when I want to initialize the threads and streams, I want to do
something like

void COMConn::connec t(int port) {
this->input = std::ifstream(" COM1:");
this->inputthread = boost::thread(& input.read); // Not correct, needs
arguments, but skip that for now
//etc for the others
}

Use initialization lists in the constructor if its possible:

void COMConn::connec t(int port) : input("COM1:"), inputthread(&in put.read)
{

}

This way the constructor of the member objects is called.

--
Thomas

[Richard Herring]

In message <11************ **********@h48g 2000cwc.googleg roups.com>,
Calle Pettersson <CP*******@gmai l.comwrites

>
Mi************ *@tomtom.com wrote:

>Calle Pettersson wrote:

Coming from writing mostly in Java, I have trouble understanding how to
declare a member without initializing it, and do that later...

General rule: don't. Just move the declaration to the point where you
initialize it, as any object is unusable until initialized.

You don't have to declare variables first; that's a old C habit which
is not
even needed in today's C, let alone in newer languages.

HTH
Michiel Salters

Really? But if I need this to be accessible to the class, but can't
call the constructor in the class definition? (Need to know which com
port in this case)
Also, I didn't know that variables could be added to a class if they
aren't specified in the header?
Or am I misunderstandin g you?

You're misunderstandin g each other.

MS is saying that you don't need to declare local variables in a
function before you need them.

You're asking how to declare member variables of a class without
initialising them. The over-simplified answer is that you can't, because
the class's constructor must invoke _some_ constructor for each member.
If they need information that's not available at construction, you have
to pass it in by calling a "post-constructor" member function at some
later stage.

What you are probably overlooking is that C++, unlike Java, has value
semantics for class types. All the class members are actual value
objects, whereas the "members" of a Java class are really just disguised
pointers.

This means that the members of a C++ class "exist" in the sense that you
can pass around pointers or references to them as soon as they have been
constructed, and before any post-construction operations have taken
place.

--
Richard Herring

[mlimber]

Thomas J. Gritzan wrote:

Calle Pettersson schrieb:

#include <fstream>
#include <boost/thread/thread.hpp>

class COMConn {
public:
COMConn(int port);
~COMConn();

char *send(char);
char *send(char, char[]);
private:
void connect(int);

std::ifstream input;
std::ofstream output;

boost::thread inputthread;
boost::thread outputthread;
};

But when I want to initialize the threads and streams, I want to do
something like

void COMConn::connec t(int port) {
this->input = std::ifstream(" COM1:");
this->inputthread = boost::thread(& input.read); // Not correct, needs
arguments, but skip that for now
//etc for the others
}

Use initialization lists in the constructor if its possible:

void COMConn::connec t(int port) : input("COM1:"), inputthread(&in put.read)
{

}

This way the constructor of the member objects is called.

As TJG says, you should initialize every member somehow in the
constructor. It looks from your example, however, that you want to
delay creation of several objects until the connect function is called.
To do this, make the members pointers (since you're already using
Boost, use boost::scoped_p tr to get automatic cleanup), initialize them
to 0 in the constructor (scoped_ptr will do this automatically, also),
and then create the objects on-the-fly in your member function:

class COMConn
{
public:
// ...

private:
void connect(int);
std::ifstream input;
boost::scoped_p tr<boost::threa dinputthread;
};

void COMConn::connec t( int port )
{
input.open( "COM1:");
inputthread.res et( new boost::thread( /*whatever*/ ) );
}

Cheers! --M

[Pete Becker]

Calle Pettersson wrote:

Coming from writing mostly in Java, I have trouble understanding how to
declare a member without initializing it, and do that later... In Java,
I would write something like
public static void main(String[] args) {
MyType aMember;
...
aMember = new MyType(...)
...
}

The roughly equivalent C++ code would be

MyType *aMember = 0;
....
aMember = new MyType(...);

[Victor Bazarov]

Pete Becker wrote:

Calle Pettersson wrote:

>Coming from writing mostly in Java, I have trouble understanding how
to declare a member without initializing it, and do that later... In
Java, I would write something like
public static void main(String[] args) {
MyType aMember;
...
aMember = new MyType(...)
...
}

The roughly equivalent C++ code would be

MyType *aMember = 0;
...
aMember = new MyType(...);

To the OP:

If 'aMember' is a local variable of the 'main' function ("method"), then
its name is wrong. It's not really a member, is it?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Frederick Gotham]

Calle Pettersson posted:

Coming from writing mostly in Java, I have trouble understanding how to
declare a member without initializing it, and do that later...

If you want to use a pointer:

int main()
{
MyClass *p;

/* "p" contains garbage right now */
...
p = new MyClass; /* Object created here */
...

delete p; /* Object destroyed here */
}
Or perhaps if you wish to pre-allocate the memory:

#include <string>
#include <new>
using std::string;

union Aligned {
void *p;
long a;
long double b;
};
int main()
{
Aligned buf[
sizeof(string) / sizeof(Aligned)
+ !!(sizeof(strin g) % sizeof(Aligned) ) ];
/* Suff happens... */

string &obj = *::new(&buf) string;
obj.~string();
}

--

Frederick Gotham