Runtime error - _CrtIsValidHeap Pointer(pUserDa ta)

[Schizoid Man]

Hi,

I have defined a very simple class as follows. I initialize the
CInventory object as: CInventory *itemInveotry;

The program just performs two functions - it reads the total number of
items and values of itemNumber, quantity and cost per item from the
user, and it prints these values back.

While printing these values, I get a _CrtIsValidHeap Pointer(pUserDa ta)
exception if I use a statement like:

for (int i = 1; i <= numItems; i++)
(itemInventory + i)->printItem();

However, if I modify the for statement to the one below, the program
works perfectly.

for (int i = 0; i <= numItems - 1; i++)
(itemInventory + i)->printItem();

Can anyone tell me why the same program works fine for one for loop, but
not for the other (equivalent?) for loop?

When the application does fail I get the following error right before
the _CrtIsValidHeap Pointer:
HEAP CORRUPTION DETECTED: after Normal block (#143) CRT Detected
application wrote to memory after end of heap buffer

Thanks in advance,
Schiz

class CInventory {

private:
int itemNumber; // holder the item's item number
int quantity; // in-stock item quantity
double cost; // storage cost per item
double totalCost; // total inventory cost

public:
// set the input info for each item
void setItem(int, int, double);
// print the item info
void printItem(void) ;
};

[Gavin Deane]

Kouisawang wrote:

Gavin Deane wrote:

Kouisawang wrote:

Stuart Redmann wrote:
Operator+ is already overloaded for pointers. Depending on the actual
type that is pointed to, operator+ for pointers will behave like this:

T* operator+ (T* BaseAddress, int Offset)
{
return (T*) int (BaseAddress) + sizeof (T) * Offset;
}

What do you mean by "predefined or primary class/type"? Pointers are as
much built in and fundamental as types like int, double and bool.
Whenever you use the + operator to add an integer value to a pointer,
the behaviour is as described by the code above. And, because interger
types and pointer types are buil in to the language, there is no way
that you as the programmer can change the way the addition of an
integer to a pointer behaves, regarldess of whether that pointer type
happens to point to a built in type (e.g. int, double, bools etc.) or
points to some user defined (e.g. class) type. That behaviour is a
fundamental part of the language.

Gavin Deane

My predefind class/type is your fundamental type. So I mean if we use a
pointer that is not of any fundamental type, will there already be its
overload function for us?
For example,

Fundamental type

int *i; // there will be the overload function of "+" for this object,
right

There is no actual overloaded operator+ function for pointers. If you
add an int to the pointer i, all there is is behaviour mandated by the
language. The code posted by Stuart Redmann neatly describes that
mandated behaviour. But no function containing that (or equivalent)
code actually exists to be called. In the same way that

int a = 1;
int b = 2;
int c = a + b;

does not call any actual operator+ function for a pair of ints. The
behaviour is built in to the language and does not need to be defined
in a function somewhere.

then what if

// myClass is the class that I have created
myClass *i; //will there be the overload function of "+" for this
object?

No difference whatsoever. There is no actual overloaded operator+
function for pointers. If you add an int to the pointer i, exactly the
same behaviour is mandated by the language so Stuart Redmann's code is
an equally useful description of that behaviour. Note that his
description is based on a type pointer-to-T and makes no assumption
either way about whether T happens to be a built in type (e.g int) or a
user defined type (e.g myclass). That makes his description a sensible
one because as far as the language is concerned, with this question,
whether the type pointed to happens to be built in or user defined is
completely irrelevant.

Gavin Deane

[Stuart Redmann]

Kouisawang wrote:

"C or C++ arrays are _always_ accessed starting from index zero up the
size of the array minus one."?

Can't we start accessing form any other positions in an array?

>>From the code above, I don't think there will be a problem if we change

from "for(int i=0;.....)"
to "for(int i=2, .....)". so not sure what do you mean by that.

I meant that if you want to access the first element of the array, you
have to use index zero. If you want to access the last element, you have
to use the index that equals the number of array elements minus one.
Note that C++ doesn't offer the possibility to define the index range
for an array, as this is allowed under Ada95 for example: The following
declaration is an Ada95 array declaration where the index starts from 50
and ends at 100 (so the array contains 51 Integers):
type Table is array(50 .. 100) of Integer;

(Unfortunately, ) such facilities are not availale under C++ (that means
you have to use some templates to achive the same behaviour).

Regards,
Stuart

[Julián Albo]

Kouisawang wrote:

My predefind class/type is your fundamental type. So I mean if we use a
pointer that is not of any fundamental type, will there already be its
overload function for us?

A pointer is a fundamental type, even if the things pointed are not.

--
Salu2

[Kouisawang]

Thanks you all of you, appreciate it :^)