Programming Forums > Application Development > C++

grumpy · Apr 23rd, 2006, 11:49 AM

This may seem circular, but raw memory is memory that your program is not treating as if it contains a particular type of data (eg an int, a pointer, a float, a struct, an enum, etc etc).

Let's say we have a type SomeType. SomeType may represent basic types (int, float, etc) or it may represent a class type that has a constructor. When you declare a SomeType, for example;

(Toggle Plain Text)

    SomeType x;

then a contiguous set of of sizeof(SomeType) bytes is found (or requested) from memory available to your program (which is usually provided by the operating system, which manages allocation of physical memory resources available to your hardware such as RAM). Once those bytes are found, your program subsequently acts as of that set of bytes represents a SomeType. That set of bytes is referred to by various names; one of them is raw memory.

Another example is when you are doing dynamic memory allocation using malloc(). For example;

(Toggle Plain Text)

    void *something = malloc(some_size);
    short *c = (short *)something;    // typecast not necessary in C

something is a pointer, and contains an address of a contiguous set of bytes. That set of bytes is another form of raw memory (with an additional property that the programmer requests it specifically, rather than letting the compiler implicitly request it from available resources). The second line tells the compiler that you wish c to be considered an array of shorts that uses the same area of memory (or, more accurately, it tells the compiler not to complain when you start doing operations, via the pointer c, on that memory that treat that memory as if it is a short).

In C++, a rough equivalent of malloc() is operator new. Operator new actually works in two phases: a call to a function named operator new() and then (for a type with a constructor) invoking a constructor (or, if creating an array of objects, invoking the constructor multiple times).

For example, by default

(Toggle Plain Text)

    SomeType *x = new SomeType;

actually works in two phases. The first phase is a call of

(Toggle Plain Text)

::operator new (sizeof SomeType)

by which your program requests raw memory to hold a SomeType. The second phase is invoking a constructor of SomeType to turn that raw memory into a valid (i.e. constructed) SomeType.

InfoGeek · Apr 23rd, 2006, 12:27 PM

Quote:

Originally Posted by grumpy

Your first comment is correct, your second is not;

(Toggle Plain Text)

#include<iostream>
using namespace std;
class X
{
  private:
       int a;
  public:
       X(int b)
        {
          a=b;
          cout<<"X invoked"<<endl;
         }
       void show()
        {
          cout<<"a=="<<a<<endl;
         }
};

int main()
{
   X a(10);
   X b=X(20);
   a.show();
   b.show();
   return 0;
}

may be I was confused with this statement:

(Toggle Plain Text)

   X b=X(20);

I know It'd invoke the copy constructor. If no copy constructor is provided, it'd create a bitwise copy. Sorry for the confusion.

grumpy · Apr 23rd, 2006, 12:39 PM

Quote:

Originally Posted by InfoGeek

I know It'd invoke the copy constructor. If no copy constructor is provided, it'd create a bitwise copy. Sorry for the confusion.

Sorry, but you've introduced more confusion. If no copy constructor is provided, the compiler will create a publically accessible copy constructor. Subject to a few other conditions (eg all data members are basic types or classes with public copy constructors, and any base classes have publically accessible copy constructors).

The only circumstance in which a compiler generated copy constructor will create a bitwise copy is for classes that have no base classes and all data members are basic types (int, double, enums, pointers, etc).

InfoGeek · Apr 23rd, 2006, 12:48 PM

Thanks for clearing up the confusion.

Apr 23rd, 2006, 11:49 AM	#11
grumpy Programming Guru Join Date: Jun 2005 Location: Adelaide, South Australia Posts: 1,260 Rep Power: 5	This may seem circular, but raw memory is memory that your program is not treating as if it contains a particular type of data (eg an int, a pointer, a float, a struct, an enum, etc etc). Let's say we have a type SomeType. SomeType may represent basic types (int, float, etc) or it may represent a class type that has a constructor. When you declare a SomeType, for example; (Toggle Plain Text) SomeType x; SomeType x; then a contiguous set of of sizeof(SomeType) bytes is found (or requested) from memory available to your program (which is usually provided by the operating system, which manages allocation of physical memory resources available to your hardware such as RAM). Once those bytes are found, your program subsequently acts as of that set of bytes represents a SomeType. That set of bytes is referred to by various names; one of them is raw memory. Another example is when you are doing dynamic memory allocation using malloc(). For example; (Toggle Plain Text) void something = malloc(some_size); short c = (short )something; // typecast not necessary in C void something = malloc(some_size); short c = (short )something; // typecast not necessary in C something is a pointer, and contains an address of a contiguous set of bytes. That set of bytes is another form of raw memory (with an additional property that the programmer requests it specifically, rather than letting the compiler implicitly request it from available resources). The second line tells the compiler that you wish c to be considered an array of shorts that uses the same area of memory (or, more accurately, it tells the compiler not to complain when you start doing operations, via the pointer c, on that memory that treat that memory as if it is a short). In C++, a rough equivalent of malloc() is operator new. Operator new actually works in two phases: a call to a function named operator new() and then (for a type with a constructor) invoking a constructor (or, if creating an array of objects, invoking the constructor multiple times). For example, by default (Toggle Plain Text) SomeType x = new SomeType; SomeType x = new SomeType; actually works in two phases. The first phase is a call of (Toggle Plain Text) ::operator new (sizeof SomeType) ::operator new (sizeof SomeType) by which your program requests raw memory to hold a SomeType. The second phase is invoking a constructor of SomeType to turn that raw memory into a valid (i.e. constructed) SomeType.

Apr 23rd, 2006, 12:48 PM	#14
InfoGeek Professional Programmer Join Date: Jun 2005 Location: India, The great. Posts: 435 Rep Power: 4	Thanks for clearing up the confusion. __________________ PFO - My daily dose of technology.

Thread Tools
Show Printable Version Email this Page
Display Modes
Linear Mode Switch to Hybrid Mode Switch to Threaded Mode

Currently Active Users Viewing This Thread: 1 (0 members and 1 guests)

Programming Forums > Application Development > C++

Constructor problem