so you can derive new structs from other structs with inheritances and such !?!?!hybrid wrote:Because a struct with a constructor is a class without private or protected members?
This is only true in certain contexts. I don't have the C++ standard available to me at the moment, so I'm going from memory here, but I believe that the rule is that data with static storage duration is default initialized to 0. That means global variables [namespace scope variables], static class members, and static local variables are all zero initialized at static initialization time, unless you provide some other explicit initializer.Also, I'm pretty sure that when you declare a pointer, int, float, etc. in a class it is automatically initialized to zero. It is only left uninitialized (garbage) if you declare it in a function.
Which, just to clarify, includes the default inheritance type.vitek wrote:The _only_ difference between a struct and a class in C++ is the default access level.
Let's puzzle it out together.mqrk wrote:Also, I'm pretty sure that when you declare a pointer, int, float, etc. in a class it is automatically initialized to zero. It is only left uninitialized (garbage) if you declare it in a function.
Code: Select all
#include <stdio.h>
class CClassy
{
public:
void * foo;
static void * bar;
};
// Note: no explicit value is assigned, but because it's static
// it gets zero initialised.
void * CClassy::bar;
struct SDerivedDefault : /* public is implicit here */ CClassy { };
class CDerivedPublic : public CClassy { };
class CDerivedDefault : /* 'private' is implicit here */ CClassy { };
void main()
{
// Note that nothing is assigned, so you get whatever garbage is in the stack.
void * garbage;
// Nice compilers will warn you about using an uninitialised variable
printf("garbage %p\n", garbage);
// Nothing is assigned, but static memory comes off the heap, and is zero initialised.
static void * zero;
printf("zero %p\n", zero);
// Note the lack of () brackets - no initialisation is performed.
CClassy * garbageHeap = new CClassy;
printf("garbageHeapFoo->foo %p\n", garbageHeap->foo);
printf("garbageHeapFoo->bar %p\n", garbageHeap->bar);
// Note the () brackets - and as if by magic, it's zero initialised.
CClassy * zeroHeap = new CClassy();
printf("zeroHeapFoo->foo %p\n", zeroHeap->foo);
printf("zeroHeapFoo->bar %p\n", zeroHeap->bar);
// You just get whatever happens to be in the stack's memory.
CClassy garbageStack;
// Nice compilers will warn you about using an uninitialised variable
printf("garbageStackFoo.foo %p\n", garbageStack.foo);
printf("garbageStackFoo.bar %p\n", garbageStack.bar);
// This expliticly zeros the first member, and any others will be
// implicitly set to 0 as well. This implicit behaviour is guaranteed
// by the spec.
CClassy zeroStack = {0};
printf("zeroStackFoo.foo %p\n", zeroStack.foo);
printf("zeroStackFoo.bar %p\n", zeroStack.bar);
// We can access the members of SDerivedDefault as it preserves the public access of CClassy
SDerivedDefault derivedStruct;
derivedStruct.foo = derivedStruct.bar;
// We can access the members of CDerivedPublic as it preserves the public access of CClassy
CDerivedPublic publicDerivedClass;
publicDerivedClass.foo = publicDerivedClass.bar;
// However, we can't access the members of CDerivedDefault because when it inherits the
// public members of CClassy, it implicitly makes them 'private'
CDerivedDefault defaultDerivedClass;
// defaultDerivedClass.foo = defaultDerivedClass.bar; // This won't compile
}
...
garbage 781C37E4
zero 00000000
garbageHeapFoo->foo 00310380
garbageHeapFoo->bar 00000000
zeroHeapFoo->foo 00000000
zeroHeapFoo->bar 00000000
garbageStackFoo.foo 781C37E4
garbageStackFoo.bar 00000000
zeroStackFoo.foo 00000000
zeroStackFoo.bar 00000000
. So some people have problem with memory.Whoa, back up. In C#, classes and structs are distinct, and structs are stack objects. This is not the case in C++. In C++, classes or structs can be allocated either on the heap or the stack.Vsk wrote:Wait a moment, if use struct (stack)
Wrong. Class, struct, heap, stack has no bearing at all on polymorphism in C++.Vsk wrote:you can NOT use polymorphism right?
No particular reason, it's just by way of illustrating that you can do it in C++, because (once again for luck) the only difference between a class and a struct is the default access and inheritance.Vsk wrote:So why should you hava a struct derived from a class?
Code: Select all
A objetoGen = B(); (withour new, in the stack).
Code: Select all
#include <cstdio>
class A
{
public:
void foo() { printf("A::foo()\n"); }
virtual void bar() { printf("A::bar()\n"); }
};
class B:public A
{
public:
void foo() { printf("B::foo()\n"); }
void bar() { printf("B::bar()\n"); }
};
int main(int argc, char *argv[])
{
A copy_that = B();
B onStack;
B * onHeap = new B();
copy_that.foo();
copy_that.bar();
A * ptrToIt;
ptrToIt = &onStack;
ptrToIt->foo();
ptrToIt->bar();
ptrToIt = onHeap;
ptrToIt->foo();
ptrToIt->bar();
delete onHeap;
}
I agree they are necessary. I just try to keep it to a minimum. A lot of the time you can pass by reference. I think people get carried away with them. If I create an actual object, then the program takes care of the memory. If I put the object in an array, it acts like a pointer sort of, but I don't have to worry about it. I'm not quite the VSK or rogerBorg type. Nothing wrong with that, I just don't have the mind for it, or maybe the interest. The dynamic stuff can actually slow a program down, and for me it's a crash waiting to happen.That's not really true, especially since pointers are the pinnacle of optimized programming.