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

[Victor Bazarov]

Frederick Gotham wrote:

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 */

There is simply *no sence* to declare 'p' before this statement.
That Calle has already been told. Just declare/define/initialise
it right where you first use it.

>

...

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) ) ];

Could you elaborate what this all is for? What are you trying
to accomplish with all that?

>

/* Suff happens... */

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

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

[Roland Pibinger]

On Wed, 19 Jul 2006 12:11:14 -0400, "Victor Bazarov"
<v.********@com Acast.netwrote:

>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?

Moreover, uninitialized variables are nor allowed in Java.

[Calle Pettersson]

Roland Pibinger wrote:

On Wed, 19 Jul 2006 12:11:14 -0400, "Victor Bazarov"
<v.********@com Acast.netwrote:

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?

Correct, I came up with that method just to show my point, and did so
in an erronus way, which understandably caused some confusion... I'll
try to be more careful in reading my code before posting in the future.

Moreover, uninitialized variables are nor allowed in Java.

Yes they are, as long as you don't try to access them. This will work
just fine:
class MyClass {
public static void main(String[] args) {
MyObject obj;
// blahblahblah
obj = new MyObject();
// etc
}
}

[Frederick Gotham]

Victor Bazarov posted:

> Aligned buf[
sizeof(string) / sizeof(Aligned)
+ !!(sizeof(strin g) % sizeof(Aligned) ) ];

Could you elaborate what this all is for? What are you trying
to accomplish with all that?

You can't do the following, because the array might not be aligned properly
to accommodate a particular type:

char buffer[sizeof(T)];

::new(buffer) T;
A possible solution would be to use a union to ensure correct alignment.

(Have you not seen this "trick" before? It's quite common.)
--

Frederick Gotham

[Victor Bazarov]

Frederick Gotham wrote:

Victor Bazarov posted:

>> Aligned buf[
sizeof(string) / sizeof(Aligned)
+ !!(sizeof(strin g) % sizeof(Aligned) ) ];

Could you elaborate what this all is for? What are you trying
to accomplish with all that?

You can't do the following, because the array might not be aligned
properly to accommodate a particular type:

char buffer[sizeof(T)];

::new(buffer) T;
A possible solution would be to use a union to ensure correct
alignment.

And how using the union you used with a 'void*', a 'long', and
a 'long double' going to accomplish "correct alignment"?

(Have you not seen this "trick" before? It's quite common.)

No, I haven't. Not to say that I've seen all the code in the world,
of course. It does strike me as strange that instead of simply
declaring a local object of type 'std::string' you declare an array
of some weird union type and then use placement new to allocate
a string. And you're saying that it's *quite common*? Indeed...

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]

Victor Bazarov posted:

And how using the union you used with a 'void*', a 'long', and
a 'long double' going to accomplish "correct alignment"?

Pick the largest integer type.

Pick the largest floating point type.

Pick the largest pointer type.

Put them together and you've got some very strict alignment.

Is it guaranteed to be strict enough? I'm not sure.

Is it likely to be strict enough? Yes, very.

>(Have you not seen this "trick" before? It's quite common.)

No, I haven't. Not to say that I've seen all the code in the world,
of course. It does strike me as strange that instead of simply
declaring a local object of type 'std::string' you declare an array
of some weird union type and then use placement new to allocate
a string. And you're saying that it's *quite common*? Indeed...

Imagine you want to have a local object in a function, but you want some
other function to initialise it:

#include <new>

void OtherFunc(void * const);

int main()
{
char buffer[sizeof(MyType)];
/* Correct alignment not guaranteed */

OtherFunc(buffe r);
}

void OtherFunc(void * const pbuf)
{
/* Do some stuff */

::new(pbuf) MyType();
}
--

Frederick Gotham

[Victor Bazarov]

Frederick Gotham wrote:

Victor Bazarov posted:

>And how using the union you used with a 'void*', a 'long', and
a 'long double' going to accomplish "correct alignment"?

Pick the largest integer type.

Pick the largest floating point type.

Pick the largest pointer type.

What happens to the pointer-to-member type? Did you know their size
is not predetermined? And there is no way to tell which one is the
largest.

Put them together and you've got some very strict alignment.

Yes, but alignment is *always* implementation-defined. Shouldn't we
stop trying to fake implementation-defined behaviour with standard
methods?

Is it guaranteed to be strict enough? I'm not sure.

Exactly.

Is it likely to be strict enough? Yes, very.

Sorry, not good enough.

>>(Have you not seen this "trick" before? It's quite common.)

No, I haven't. Not to say that I've seen all the code in the world,
of course. It does strike me as strange that instead of simply
declaring a local object of type 'std::string' you declare an array
of some weird union type and then use placement new to allocate
a string. And you're saying that it's *quite common*? Indeed...

Imagine you want to have a local object in a function, but you want
some other function to initialise it:

#include <new>

void OtherFunc(void * const);

int main()
{
char buffer[sizeof(MyType)];
/* Correct alignment not guaranteed */

OtherFunc(buffe r);
}

void OtherFunc(void * const pbuf)
{
/* Do some stuff */

::new(pbuf) MyType();
}

Don't see it as "common" either. What you ususally see done is

MyType myobject = OtherFunc();

It's not entirely "initialisation " but with optimizations the
compiler is allowed to do, it's *more likely* to be correct, and
therefore *more common*, AFAICT.

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]

Victor Bazarov posted:

>Is it likely to be strict enough? Yes, very.

Sorry, not good enough.

Presumably, that was the antecedent for the following:

http://groups.google.ie/group/comp.s...b27dc9f?hl=en&
--

Frederick Gotham