I wasn’t clear, for second question you should use references instead of pointers.

As I said in case you use references user always pass initialized objects as params.
In case you user pointers user can pass uninitialized pointers by error or he can suppose that second object ( copy to ) will be created by function.

With references you shouldn’t add any checks to you function.
With pointers you should at least check if pointers are not null (and throw exception), more than that, if they are not null pointers, they could be still uninitialized and you can’t throw exception or report user about what is wrong.

With references you could do all the things exactly the same as with pointers, but define by default that user should create objects. So why mess up with pointers at all?

If you read code that you don’t know it is often impossible to distinguish in parameters from out parameters. Therefore non-const pointers should be used for out parameters and for in parameters it’s usually const reference or pointer to const.
In good C++ code it is rare to pass around ownership of anything so it should be clear that the pointer does not mean any change of ownership if not explicitly documented or hinted by the method name (like createFoo()). Qt has it very, very right. I hate non-const references, I really do. They are a first-rate obfuscation technique.

7KqZZ6 hctstmhbgogb, [url=http://xxojvuondkzk.com/]xxojvuondkzk[/url], [link=http://zqpeucqxwvjz.com/]zqpeucqxwvjz[/link], http://wcpoklxnldgf.com/

vbR21F mkyufjpyuryd, [url=http://zhraulewvupl.com/]zhraulewvupl[/url], [link=http://rulrssvxtfjp.com/]rulrssvxtfjp[/link], http://wjujifrrsnnd.com/

To 2.:
I recommend a third variant:
copy( Record* to, const Record& from )

to first, because the order for arguments is best “out” before “in”, so the modified object comes first, then some non-modified parameters.

And I found it helpful to have modified arguments given as pointers instead of reference, so in the calling code these arguments stay out, due to the address operator & before the variable name (I just wish C++ had a calling syntax similar to Object-C): copy( &target, source );

* Use d-pointers whenever you have a public class.
* Better never use protected data members. Expose them through protected methods.
* Use QSharedDataPointer for struct-like classes that you want to copy around a lot (QString is the typical example). Using it with QObjects does not make any sense as those cannot be copied anyway.

As for the copy:
Instead of the reference variant use proper copy operators and constructors (those can be perfectly combined with QSharedDataPointer in case Record is a struct-like class). There are only two reasons I can see for a copy method:
1. Copying the contents of a QObject (again: QObject cannot be copied the C++-way)
2. a class hierarchy where you use some visitor-like pattern or something. In this case you use pointers because it is way easier to read.

Hope this helps.

6RcXmc wlivsakkgwzt, [url=http://dlshjjgvoqba.com/]dlshjjgvoqba[/url], [link=http://rbzzdvsfwznw.com/]rbzzdvsfwznw[/link], http://yfaonpennbrc.com/

8e4cTC fpydekusfmxq, [url=http://jcisrkqmdadd.com/]jcisrkqmdadd[/url], [link=http://gtdpocyraxuu.com/]gtdpocyraxuu[/link], http://ajvyapaxnjax.com/

The sacrifice of readability is mostly a matter of taste I think. When you use only one letter for the variable then only “d->” is added at places where you otherwise would read only the member name. I for sure found it much more a pleasure to read the Akonadi code with d pointers than my own code. But the absence of d pointers might not be the only reason =:D.

Anyway, still enough to learn about writing beautiful code.

In Akonadi they solved this by moving the class declarations of private classes to seperate header files.

class Item -> item.h, has member ItemPrivate -> item_p.h

This is a method I really like. The code of the akonadi libraries is very easy to read if you ask me.

ujpn2c kkalqwnazflp, [url=http://mcbgdiforvhs.com/]mcbgdiforvhs[/url], [link=http://dicitcyxvira.com/]dicitcyxvira[/link], http://qdokchxjxwkm.com/

For the copy(): use pointers, never use non-const references.
When you read the calling code, you don’t get a hint that the value of an argument might be modified by the called function if it is called with a reference. If it is a pointer, there can be only two reasons for that:
-it is actually an array
-the called function modifies the variable
So if the argument is const, use a reference or pointer. If it is non-const, use a pointer.
Check out “Designing Qt-Style C++ APIs” by Matthias Ettrich:
http://doc.trolltech.com/qq/qq13-apis.html

Regarding pointers vs. references:
A pointer can be NULL, a reference can’t be something similar. This can be both an advantage and a disadvantage depending on what you want to do (see QWidget: if the parent is NULL, it’s a top level widget, if it’s not NULL, it’s a child widget, this works nicely with pointers).
Additionally, a pointer can point to something which doesn’t exist anymore. The same is true for references, they can also reference something which doesn’t exist anymore. In both cases you can’t test for it:

int main()
{
int i=17;
int& ir=i;
{
int j=3;
ir=j;
}
// at this point ir references a non-existing variable
return 0;
}


Alex

Yes sure, you can even do something like that:

{sabatier.xxxx}[160] cat *.cpp && g++ *.cpp && ./a.out
#include using namespace std;
char FuckingFunction(int &FuckingReference = *static_cast(NULL)) {
return &FuckingReference?FuckingReference+’0′:’X';
}

int main(int uArgs, char **pArgs) {
cout < < "yEp dah Fuckoff fucking rEfereNCe" << endl;
cout << "yOp what that? -> ” < < FuckingFunction(++uArgs) << endl;
cout << "yOp what that? -> ” < < FuckingFunction() << endl;
return 0;
}
yEp dah Fuckoff fucking rEfereNCe
yOp what that? -> 2
yOp what that? -> X
{sabatier.xxxx}[161]

But what you forgot is that you made a bad code. With bad code you can prove everything…
I can provide you something in contradiction found in… C++ language:
A &operator=(const A &);

Please read scott meyers… a real good reference in C++

This is invalid code, NULL references are not allowed in C++ and using them invokes undefined behavior. And invoking undefined behavior means the compiler can output code doing anything, even formatting your hard disk.

d pointers:

d pointers are needed (or, at least, very much recommended) if you need to maintain binary compatibility for any reason, such as a public class in a library. This is the reason kdelibs has them all over, and Akonadi uses them.

However, for internal classes, I wouldn’t bother unless it’s an implicitly shared class (using QSharedDataPointer, for example). Why? Well, you have to manage the pointer (one of the most common causes of memory leaks in KDE I’ve seen is people not delete d-pointers). Also, if you use a sane initialisation method (a constructor initialises an object completely as far as possible, including setting unused pointers to 0 and other variables to a sensible default), the inititialisation of members used in class Foo takes place in class FooPrivate, which is not necessarily where you’d look.

However, if you don’t use d-pointers, I’d use the convention of starting member names with m_, since that makes it obvious that something is a member and not, say, a function-local variable in the code and also provides a distinct namespace for members and methods. This is often important for variables with getters and setters, because you often want to call the getter and the variable the same thing.

iBMDXL ccypvsixbxsh, [url=http://gmnrthjdbgac.com/]gmnrthjdbgac[/url], [link=http://frmxoxfxkocc.com/]frmxoxfxkocc[/link], http://ivvlxeocbdpt.com/