NaNDude · HackerTrans

vor 3 Jahrendiscuss

i've seen you'v been recommended to learn C in another thread. in C++, the use of "references" really require to understand the concept of pointers, they'r basically the same things but not exchangeable, because references hide some aspects of pointers that make the syntax a little more shitty. in fact the syntax of references (the use of '&' in parameters) come from the syntax of pointers, it means "address of".

int incr2(int& value) { value = value + 1; return value; }

is the same as

int incr3(int* value) { (*value) = (*value) + 1; return *value; }

and they will be used diferently for the same result :

void main() {

  int a_value = 5;

  int result2 = incr2(a_value); // result2 = a_value = 6;
  int result3 = incr3(&a_value); // resulst3 = a_value = 7;

}

in the call to incr3 "&a_value" can be read : address_of "a_value".

and in the body of incr3 "*value" can be read : content of address "value".

and finnaly in the prototype "int incr3(int* value)", "int*" can be read : pointer to an int, or address of an int.

pointer/address are a fundamental concept for programming at large, the concept of "indirection".

all this may seem unrelated at first, but in your Complex problem, you can try something like :

#include <iostream>

...

Complex c2;

std::cout << &c2 /* address of c2 */ << std::endl;

and in your copy constructor :

Complex(Complex& c) {

  std::cout << &c /\* address of c \*/ << std::endl;

  ...

}

you will see that, with a reference, the addresses are the sames, but without references you will get different addresses meaning that your variables are'nt the same (in the case of function parameters/arguments they are copies of the parameters values, that's why we call this "pass by value" semantic, rather than "pass by reference" or "pass by address" or box, or indirection, or whatever having the same meaning).

hope this help.

NaNDude

vor 3 Jahrendiscuss

implicitly yes.

NaNDude

vor 3 Jahrendiscuss

> Correct me if I'm wrong: In int main, "complex c3(c2)" creates a copy of c2 and thus passes c2 to copy constructor.

it never pass c2 to the copy constructor.

a) it pass a reference to it, if the copy constructor is defined as "Complex(Complex& refr)"

b) it pass a copy of it, if the copy constructor is defined as "Complex(Complex copy).

just dont consider references in the context of objects or copy constructors, but in the context of a simple function :

int incr1(int value) { value = value + 1; return value; }

vs

int incr2(int& value) { value = value + 1; return value; }

in incr1 value is local to the function, it is a copy of the value you pass as parameter

in incr2 it is'nt local to the function, there is no copy done.

// not tested sample :

#include <assert.h>

void main() {

  int a_value = 2;

  int result1 = incr1(a_value); // no reference, a copy, local to the function, is made.
  assert(a_value == 2);         // ok
  assert(result1 == 3);         // ok

  int result2 = incr2(a_value); // with reference, there is no copy made.
  assert(a_value == 2);         // error, the original a_value parameter as been incremented.
  assert(a_value == 3);         // ok
  assert(result2 == 3);         // ok

}

the incr1 is more "secure" (it is said "pure", for this and others reasons), but it always make a temporary int that is a copy of the parameter you give to it.

the incr2 is less "secure", but there is no temporary int created.

that's exactly to prevent the temporary int/Complex that copy constructors always require a reference, because when you call the copy constructor explicitly (in : Complex c3(c2); ), the copy constructor for the temporary will be called implicitly too, and the copy constructor for the temporary of the temporary called implicitly will be called implicitly too, etc.

hope this help.

NaNDude

vor 3 Jahrendiscuss

the most important point to keep in mind is the default pass by value context.

without defining a copy constructor, the compiler will do the copy himself, the point is : there is no copy constructor to call, so you have :

1) first the new Complex c3 is allocated,

2) there is no copy constructor to call

3) the compiler do the job, the memory used by c2 is copied on c3.

end of the story, no parameter value.

when adding a legal copy constructor (pass by reference), you may consider the reference like some sort of pointer. this is false, but help to understand the memory behavior of a copy constructor. then you have something like :

1) first the new Complex c3 is allocated

2) the "memory" for c, the reference/pointer to c2, is allocated.

3) the _address_ of c2 is copied in c.

4) the c3 constructor start with the reference/pointer/address of c2 as parameter.

end of the story, normal "pass by value" of an address.

finaly, if a copy constructor _without_ reference/pointer was legal, you will have:

1) first the new Complex c3 is allocated,

2) another new Complex, the c3 copy constructor parameter value c, is allocated.

3) instead of directly copying c2 memory to c, there is the c copy constructor to call (with a copy of c2 as parameter value)

4) another new Complex c_bis, the c copy constructor parameter value (c), is allocated.

5) instead of directly copying c2 memory to c_bis there is the c_bis copy constructor to call (with a copy of c2 as parameter value)

6) another new Complex c_bis_bis is allocated ... etc.

the problem is that a copy constructor is _implicitly_ called to create a copy, which transform a pass by value semantic in an infinite loop of allocations on the stack.

hope this help.

NaNDude

vor 4 Jahrendiscuss

not a response to the question but... actually replacing an usage usually change this usage, but the effect on demand when thoses are primary ressources is'nt linked to this change. coal for exemple is a good source of synthetic fuel (fischer-tropsch process) and 1/6 of actual chinese fuel source or the wood demand exploded with coal usage, for mining it, before surface mining. just to point out that there is mostly no such thing as "energy transitionning" in the humain history, it's a cumulative process.

NaNDude

vor 4 Jahrendiscuss

may be the increases of the last forty years have'nt been studied as thoses of the 60s to 70s, but regulatory costs are still a reality, the french EPR for exemple got a 20billion increase in cost during the construction for changes in security standards.

NaNDude

vor 4 Jahrendiscuss

this is categorical thinking. behavioral psychology, molecular genetics, behavioral genetics, ethology, endocrinology, etc. will all provide their own "demonstrated answer" to the same question, even when they will be contradictory to each other.

comments