Re: Creating an instance of a class
On Feb 19, 10:06 am, "jimbo" <joachim.zett...@googlemail.com> wrote:
On 19 Feb., 09:55, Piyo <cybermax...@yahoo.com> wrote:
jimbo wrote:
Dear all,
I am more or less new to c++ programing and therefore still have
problems with some fundamentals :(
At the moment I try to build a GUI-Application with Qt4. Sometimes I
have seen in the tutorials I have to instance a class with the new
command. Like QWidget QLabel *label = new QLabel("Hello World"); Th=
en
I have created a pointer to a QLabel Object. The other way I have seen
is to just use QLabel label("Hello World"); Without a pointer and
without the new statement.
So to access the functions of the QLabel class I have to use the "."
for the part without pointer like label.show and for the pointer part:
label->show.
Can somebody explain me, why it is possible to use the two ways and
what is the difference in general.
Thank you a lot in advance.
jimbo
Given an object and a pointer to that object, you can access members
like so:
class foo
{
public:
int bar;
};
int
main()
{
foo* baz1 = new foo();
foo baz2;
baz2.bar; // cool
baz2->bar; // not cool
baz1.bar; // not cool
(*baz1).bar; // cool but too long
(baz1)->bar; // short hand version of the previous line
baz1->bar; // even shorter version of the previous line
}
In summary, "->" is a short hand notation to dereference the
pointer first and then access its member.
Good Luck!
Hi to all of you,
first of all, thanks a lot for the explanation. I didn=B4t know that
this whole topic is related to where the memory is allocated. Now with
heap and stack I can imagine a little bit better what I am doing :)
But to come back to my own little example. When i am already in a
main() function of my app and i create the instances there without the
new operator then i will have no problems concerning the use of the
instance in a different scope because i am already in main and main is
not ended yet, or?
Yes, the scope of main is a superset of almost all other scopes
(static being the only exception that I can think of right now).
I think i need to take it more carefully when i implement an own class
and use functions there.
It's not so much when implementing a class as when using it. But since
we are on the topic of implementing classes and dynamic memory
allocation I can say that if you implementation uses new instantiate
members (perhaps in the constructor) you should probably delete them
in the destructor, like so:
class Foo {
int* arr; // An array
public:
Foo(int i) : arr(new int[i] { } // * allocate an array of size i
~Foo() { delete[] arr; } // Free the memory used
};
This way a user of the class will never have to worry about how the
class manages its resources, it will just work.
* If you don't understand the ': arr(new int[i] { }'-bit it's an
initializer-list and does the same thing as '{ arr = new int[i]; }',
for a more detailed explanation see http://www.parashift.com/c++-faq-lite/c=
tors.html#faq-10.6
--
Erik Wikstr=F6m