why i can't assign I[5] ?

Quote:

---

Originally posted by AnthonyMai
Since it is a simple class, please quit the talk of class design, and proper data encapsulation, and a bunch of other high level OOP concepts. These concepts may be good when the design is complicated. But they are not important here when things are rather simple and can be done in the simplest way.

---

We're on a forum. When people are on forums, they typically "dumb down" their examples so that they can reproduce their COMPLICATED usages with very SIMPLE ones so that the bare concepts are explained. Because of this, it'd be nice to see a solution that would scale with complexity.

Now, I don't mind very specific solutions, but your post had NO
such disclaimer. Nowhere in your post did you say "This is only
useful for very simple classes who are basically structs". Instead,
you insult and badmouth the prior posters. Nice attitude.

--Paul
[Yves : please, be calm / small edits]

Quote:

---

Originally posted by AnthonyMai


Graham, you did not give an answer that is correct AND straight. By "straight" I mean it should be concise and elegant. You solution calls the constuctor individually. Obviously if there are 1000 elements in the array you would call constructor and destructor 100 times respectively, if there are 10000 you will call 10000 times. So it is not straight at all.

---

But there aren't 1,000 or 10,000 elements in the array, are there? There are FIVE. The original question specified a five-element array. It was declared as having five elements. It was initialised with five elements. Not 1,000, not 10,000, not 10 or 50 or 1,000,000. FIVE. Would you also explain, then, how your answer using normal C-style syntax would alleviate the problem of an array of 10,000 elements? You save one character for each initialiser - you type 60,000 characters to my 70,000. Do you really think that in the face of that, that the calling of constructors and destructors would be an issue? It wouldn't even get to that stage, because you physically would not write such an intialisation (and I'm not even going to mention optimising away the temporaries, because you'll just come up with some load of old cobblers about how it's impossible for the compiler to do it).

Quote:

---

With due respect I do NOT think you can write a struct with member function in C. Structs with member functions is a feature available in C++ but not C.

---

And did I not say "remove the access specifiers and member functions"?

The fact is that the answer I gave was correct, simple and straight.

[Yves : removed a bit]

Quote:

---

Would you also explain, then, how your answer using normal C-style syntax would alleviate the problem of an array of 10,000 elements? You save one character for each initialiser - you type 60,000 characters to my 70,000. Do you really think that in the face of that, that the calling of constructors and destructors would be an issue?

---

Typing one less or one more charaters was never an issue in any programming environment. The typing is a negligible part of a programmer's job. I would never consider some code simpler or more complicated, for the consideration of the typing work load. NEVER.

You completely missed the point. The point is not that you have to spend more time typing the keyboard when an "A" is added. The point is you are making un-necessary calls to the A constructor and destructor. When you do that 1000 or 10000 times it do inflate the code size (executable code size, not source code size!) un-necessarily.

Quote:

---

Originally posted by PaulWendt


What you don't seem to understand is that we're on a forum.
When people are on forums, they typically "dumb down" their
examples so that they can reproduce their COMPLICATED usages
with very SIMPLE ones so that the bare concepts are explained.
Because of this, it'd be nice to see a solution that would scale
with complexity.

---

Ok, I'll bite:

Code:

---

#include <iostream>
#include <algorithm>

class A {
    private:
    int x,y ;

    public:
        A(int a=0,int b=0){y=b;x=a;}
    void init(int a,int b){x=a;y=b;}
    void show(){std::cout<<x<<" "<<y<<std::endl;}
};

struct InitA
{
    InitA(unsigned start) : m_start(start) { }
    void operator() (A& curA)
    {
        curA.init(m_start, m_start);
        m_start++;
    }

    private:
        unsigned m_start;
};


class AInitializer
{
    public:
        AInitializer(A* myA, unsigned int amount = 1)
        {
            std::for_each(myA, myA + amount, InitA(1));
        }
};

using namespace std;

int main()
{
    A l[10000];
    AInitializer(l, 10000);

    l[3].init(8,3);
    A* p;
    p = l;
    p->init(3,4);
    for(int i=0;i<10000;i++)
    (*(p+i)).show();
}

---

No change of the class definition of the OP was done. An initializer object is all that's needed that initializes the values properly. Of course, there will be more elegant ways and is not the only solution.

Regards,

Paul McKenzie

All the solutions PM, Graham and other proposed all based on some sort of manipulation of the object data.

Since these objects are initialize with some sort of constant arrays. It is reasonable to assume that those are MEANT to be const objects. You can use various member functions to access the object data, but you are NOT allowed to touch or change the object data in any way.

How would you initialize a const object array? You can't construct and then initialize, right, PM? For const objects, you have to initialize while construct.

And why construct temporary objects and destroy them, while all that matters is x gets x's value and y gets y's value, from a constant integer list.

And who says an object must needs some sort of constructor function to be constructed? For simple objects, you can construct objects WITHOUT constructor and destroy them WITHOUT destructor. Do you call any constructor when you declare an integer? Does it call a constructor 1000 times when you declare a 1000 elements integer array?

My solution is still the most elegant one since no constructor ever needs to be called. When it comes to declaring a global const object array, my solution requires not a single run time operation to be carried out.

One could always make a separate binary file, map (or load -- think c++ generic) that data file to memory, then just call the various data locations whatever data structures you want... except that the struct or class might have methods. If there are methods, you'll need to have some c++ runtime management to connect up the various instantiations, so in such a case, you will be incorrect Mr. Mai. If, as originally trimmed down and posted, there are no methods, then maybe my solution is more elegant than yours Mr. Mai. It keeps the code much more clean. I once defended you Mr. Mai. I thought you were just a young punk trying to prove yourself, like I was once. But I don't like you Mr. Mai. You are not nice. And not as smart as you think you are.

[Yves : pointless post]

Everybody,

Please calm down. I edited some of the previous posts to remove the most flame-like replies. This is a forum where experts exchange ideas and comments and there is no need for flame-wars.

Anthony,

Check your private messages and especially the one I sent you about your message style. Apply that.

As usual, Mai is right and everyone else is wrong. Why can't the
world just accept that? I guess we're all religiously fanatic
language lawyers....

The fact of the matter is that Mai's solution is more C-like. You can
quibble semantics for all of eternity, but his solution approaches
the C language ... and it's not all that far from it. In fact, if you're
going to treat a class like that, you may as well just make it a
struct.

Also, Mai never bothered to address the fact that this simple
class might be more complicated in reality. It seems that a lot of
his defense for saying his case is justifiable is that the class is so
simple and so it doesn't need the extra complexity of a
non-compiler generated constructor. If the class becomes more
complex, however, [or if this is just an example] then his approach
won't help you out all that much.

Furthermore, if you care about information hiding, his approach
is not going to help you. Making the data members public might
work for you ... but then again, it might not. So, this approach is
not generically elegant, but it's elegant in the "specific-tailored my
solution performs 0.33% faster than yours and consumes 1.8%
less memory" line of thought.

Let's leave it at that.

--Paul

the array
A I[5] = {(1,1), (2,2)...} cannot be initialised this way.

the problem is the comma operator in the brackets. (1,1) translates as 1 and the constructor for A is called with a single parameter. The second parameter default to 0 as it is declared.

for reference look at this:

int i = (1,2);

the result is

i == 2

sorry for annoying you.

Quote:

---

Originally posted by EMI_J
the array
A I[5] = {(1,1), (2,2)...} cannot be initialised this way.

the problem is the comma operator in the brackets. (1,1) translates as 1 and the constructor for A is called with a single parameter. The second parameter default to 0 as it is declared.

for reference look at this:

int i = (1,2);

the result is

i == 2

sorry for annoying you.

---

It's not an array of int's, though; it's an array of A's. A has a
constructor that takes two arguments; an int has no such
constructor.

--Paul

...ah, but A is not a POD, and the compiler doesn't know that the "(n,n)" list should refer to the constructor for A. Which is why you need to be explicit and put "A(n,n)". But then again, that's a hopelessly wrong-headed and inelegant thing to do, isn't it? ;)

yes, Graham, you are absolutely right

for Paul Wendt:
(1, 1) translates to 1 then to int(1) then to A(1, 0)

Quote:

---

Originally posted by EMI_J
yes, Graham, you are absolutely right

for Paul Wendt:
(1, 1) translates to 1 then to int(1) then to A(1, 0)

---

Sorry. I guess I misunderstood you since someone already had
said this. I thought you were quoting THAT person telling them
that they were incorrect.

Quote:

---

Furthermore, if you care about information hiding, his approach
is not going to help you. Making the data members public might
work for you ... but then again, it might not. So, this approach is
not generically elegant, but it's elegant in the "specific-tailored my
solution performs 0.33% faster than yours and consumes 1.8% less memory" line of thought.

Let's leave it at that.

--Paul

---

Where did you get the 0.33% and 1.8% figure? Are you sure it is not 0.1%, or more, or less?

If you want numbers here are the hard numbers.

Code:

---

class A
{
public:
        int x;
        int y;
public:
    A(int a, int b) {x = a; y = b;}
        void init(int a, int b){x=a;y=b;}
        void show() const {printf("%d %d\r\n", x, y);}
};

class B
{
public:
        int x;
        int y;
public:
        void init(int a, int b){x=a;y=b;}
        void show() const {printf("%d %d\r\n", x, y);}
};

const A A_array[5] = {A(1,1),A(2,2),A(3,3),A(4,4),A(5,5)};
const B B_array[5] = {{1,1},{2,2},{3,3},{4,4},{5,5}};

---

Here is what my solution, B_array, looks like when compiled:

Code:

---

CONST        SEGMENT
_B_array DD        01H
        DD        01H
        DD        02H
        DD        02H
        DD        03H
        DD        03H
        DD        04H
        DD        04H
        DD        05H
        DD        05H
CONST        ENDS

---

Here is what Graham's solution, A_array looks like:

Code:

---

_TEXT        SEGMENT
_$E1        PROC NEAR                                        ; COMDAT

; 27  : const A A_array[5] = {A(1,1),A(2,2),A(3,3),A(4,4),A(5,5)};

  00000        b8 01 00 00 00        mov        eax, 1
  00005        8b c8                mov        ecx, eax
  00007        a3 00 00 00 00        mov        DWORD PTR _A_array, eax
  0000c        b8 02 00 00 00        mov        eax, 2
  00011        89 0d 04 00 00
        00                mov        DWORD PTR _A_array+4, ecx
  00017        8b c8                mov        ecx, eax
  00019        a3 08 00 00 00        mov        DWORD PTR _A_array+8, eax
  0001e        b8 03 00 00 00        mov        eax, 3
  00023        89 0d 0c 00 00
        00                mov        DWORD PTR _A_array+12, ecx
  00029        8b c8                mov        ecx, eax
  0002b        a3 10 00 00 00        mov        DWORD PTR _A_array+16, eax
  00030        b8 04 00 00 00        mov        eax, 4
  00035        89 0d 14 00 00
        00                mov        DWORD PTR _A_array+20, ecx
  0003b        8b c8                mov        ecx, eax
  0003d        a3 18 00 00 00        mov        DWORD PTR _A_array+24, eax
  00042        b8 05 00 00 00        mov        eax, 5
  00047        89 0d 1c 00 00
        00                mov        DWORD PTR _A_array+28, ecx
  0004d        8b c8                mov        ecx, eax
  0004f        a3 20 00 00 00        mov        DWORD PTR _A_array+32, eax
  00054        89 0d 24 00 00
        00                mov        DWORD PTR _A_array+36, ecx
  0005a        c3                ret        0
_$E1        ENDP
_TEXT        ENDS

---

So which one is more elegant? Is it JUST 0.33% faster and takes 1.8% less memory?