Memory Issue...?

I have a program writing to a file, and I have several arrays that hold 100 to 2000 elements each. Everything has gone well so far, but now when I try to simply declare another array of 200 elements, part of the file is not written correctly (it is blank at the top in some places). However, when I declare this new array with only 20 elements, the file writes fine.

What the heck? Why is it doing this? I don't know how I could allocate memory because the arrays are char [] arrays rather than char* arrays, so I can't say

buffer = (char*) malloc (2000);

Are the arrays declared within main()?

in c++ you could simply use the new operator to allocate memory.

Code:

---

//create a pointer to a "block" of memory
char *buffer = new char [2000];

---

just be sure you delete ( delete [] buffer; ) it when you done.

also to check if your allocating bad memory.

Code:

---


char *buffer; //create pointer to memory

try {
  buffer = new char [2000]; //allocate memory
  memset(buffer, 0, sizeof(buffer));
}

catch(bad_alloc & b) {    // catch the exception if something went wrong
  cout << b.what();
}

---

EDIT: also if you need further help, post your code and you will most definately get the answers you seek ;)

Yes the arrays are declared within main, so they are not global. I only use these arrays in the main function, and I do declare another variable with the same name inside of another function. I don't think they are conflicting though.

I will try creating a pointer to a block of memory as well as deleting the array after I am finished with it. We'll see what happens, and if it doesn't work I'll post code.

Thanks for the help! Much appreciated!


btw, when you catch exceptions, how do you know the parameters to catch, like "bad_alloc & b", and how do you know the variables inside of the object (such as b)? Never done exception handling before.

exceptions usually work like this

Code:

---


#include <iostream>
#include <string>

//+--Create an exception class---+
class Exception 
{
  string errorString;

public:
  string getError( ) {return errorString;}
  Exception(string s);
};

//+--Call the class constructor---+
Exception::Exception(string s) { errorString = s }

int main()
{
  int num1 = 5;
  int num2 = 7;

  try {
    if(num1 > num2)
      std::cout << "The difference is: " << (num1 - num2);

    //+----If num1 is not less than num2 we throw our exception object
    else
      throw Exception("The result will be negative");
  }

  catch (Exception e) {
    std::cout << e.getError();
  }

  return 0;
}

---

and if you ran the program it would output "The results will be negative"

the new operator happens to throw its own exception automatically.

Edit: This code is untested and is only an example of how I understand exceptions.

>Yes the arrays are declared within main

You are probably overflowing the stack. You could either declare the bigger arrays above main(), or use new to create dynamic arrays. A third option is use the STL vector.

> buffer = new char [2000]; //allocate memory
> memset(buffer, 0, sizeof(buffer));

sizeof on a pointer does NOT tell you how many bytes it is pointing to.

Doh, im so sorry. I forgot all about that.

memset(buffer, 0, 2000);

Thanks for correcting that slip up Salem :)

>>A third option is use the STL vector.

And a fourth option, if you're dealing with text (which it sort of looks like, because the arrays are arrays of chars), is to use the std::string :)

I got it! Part of the trouble was that I was using sizeof() to initialize the array elements, and it was taking the size of the variable(s) in bytes. The thing about dynamic memory using new also helped.

Thanks so much for the help and all the info!

btw, what I am doing is writing a Bible file using the following (my own) format:

length of title in bytes (1 byte)
title (50 bytes)
length of copyright in bytes (1 byte)
copyright (50 bytes)
number of books (2 bytes)
locations of each book (4 bytes each)
length of book name in bytes (1 byte)
book name
number of chapters in book (2 bytes)
locations of each chapter (4 bytes each)
[beginning of chapter]
number of verses in chapter (2 bytes)
locations of each verse (4 bytes each)
length of each verse in bytes (2 bytes)
verse text

Also, how do you know when the array is big enough to use new?

You could use new to allocate an array of 2 elements if you wish.
Or you could create a large array by

Code:

---

int array[2000];

---

Now, the difference, is where you allocate it.
I am not comfortable enough with the subject to go into detail, but one method allocates memory on the "heap" and the ofther in the "stack".

I am not extremely sure about this though.

>>btw, what I am doing is writing a Bible file
I like that :) I was actually thinking of doing something similar, so I could keep a neat record of any notes I wanted to take while reading, i.e. notes by chapter or by verse, by book, etc. Once you've got this thing written, would you mind giving me a copy? :)


>>Also, how do you know when the array is big enough to use new?
Well, when it's big enough for the program to screw up, then you know to use new ;) But my arrays generally don't exceed 4-5000. There isn't usually a reason for it; sometimes you need a large array to ensure that all input for a line ends up in the same array, etc. but if that's the case, often a std::string will work better because it does everything dynamically anyway. Also, if you can calculate how large an array you need (i.e. you read a header that says '6 bytes for title, 23 bytes for summary') then you can create an array using 'new' that fits exactly. On the other hand, if you know that something will never be more than say 50 characters long, you can create a non-dynamic array of length 51 (for the NULL at the end), because it's 'safer', meaning that it gets destroyed automatically when it goes out of scope. Also, if you want to create the array and have it not disappear after a function returns (so that the calling function can use it), you can allocate it with 'new' - just remember to delete[] it in the calling function.

**EDIT**
I think the 'stack' is a block of memory that gets allocated when the program begins; all the variables in the program generally are created on the stack. The 'heap' is a big pile of memory somewhere that is shared by all programs, and when you use 'new', it allocates a block of memory on the heap and returns its memory address (its pointer).

Hope this helps! :)

Quote:

---

Originally Posted by Hunter2

>>Once you've got this thing written, would you mind giving me a copy?

---

Sure will. It'll be free. The only thing is I am only able to get my hands on a copy of the King James version, and I don't know where I can get others.

Hmm.. well, you could probably get another one from pretty much any bookstore. Except, come to think of it, you probably want to watch out for copyrights. It would be a real bummer if you spent half a year typing it in and then got sued :D

Are you actually going to type all of this out!?

If you are, you deserve a freakin cokie or something... I would have just found a PDF or txt file lol.

>>If you are, you deserve a freakin cokie or something...
Heh, I agree... gee, that's actually a good idea, I wonder if there are any txt's out there (PDF looks difficult to handle)? *vanishes to search google*

**EDIT**
Done searching... wow, there's a lot of free bible software out there lol :rolleyes:
This seems to be a great place, although you'll need to convert the format to your own (which means you'll have to figure out the format it comes in).
http://bibledatabase.org/bibles.html

**EDIT2**
Wow, it's just a textfile with headers for each verse! This could be fun...

Code:

---

(overall verse #) *tab* (book #) *tab* (chapter #) *tab* (verse #) *tab* (verse text)
*repeat*

---

Ha...no way. That would be really error-prone. I found a text file of the King James Bible here. Maybe I could contact some Bible publishers and see if they'll give me something similar. Or maybe in order to use their version you'll have to pay [them] a little (hopefully not).

If you want to keep it simple, you could do this.

Have a file named Genisis.txt with this in it

Code:

---

1:1 In the..
1:2 blah

---

I decided to try out a little test about how you would go about allocating memory and such for each book. (You could just load one book, or segments of books at a time)

Code:

---

#include <iostream>
#include <fstream>

char *fileBuffer;

const long BookSize(char *book)
{
  std::ifstream tempFile(book);
       
  if(!tempFile.is_open()) {
    std::cout << "Error opening " << book;
    exit(1);
  }
       
  tempFile.seekg(0, std::ios::end);
  long fileSize = tempFile.tellg();
  tempFile.close();
       
  return fileSize;
}

void ReadBook(char *book, long fileSize)
{
  std::ifstream file(book);
       
  if(!file.is_open()) {
    std::cout << "Error opening " << book;
    exit(1);
  }
       
  file.read(fileBuffer, fileSize);
       
  file.close();
}

int main()
{
  char book[50];
       
  std::cout << "Type in the name of a Book: ";
  std::cin  >> book;
       
  const long size = BookSize(book);
       
  fileBuffer = new char [size];

  ReadBook(book, size);

  std::cout << std::endl;
  std::cout << fileBuffer;
 
  delete [] fileBuffer;
  return 0;
}

---

note this is just some example code.

This is what happens

Code:

---

Type in the name of a book: C:\Genisis.txt


1:1 In the begining, God created the heaven and the earth.
1:2 Something about light.


---

Where I have a text file named Genisis.txt in C:\ that contains

1:1 In the begining, God created the heaven and the earth.
1:2 Something about light.

Hey, that's a pretty cool textfile. It solves the problem of having to map numbers (book 1, book 2, etc.) to names (Genesis, Exodus, etc.). It might be a bit harder to parse though, since it has [ and : and other stuff like that... Well, good luck with it :) I'll be trying to write a converter program for the bible texts on the other site to a more convenient format (i.e. yours ;)).

Here's the program I threw together to convert that file (here) to the format I want.

The only thing about the asv version at bibledatabase is that it includes the Apocrypha, and I'm not Catholic. I'm not going to bother with it, but if you want to that's cool.

Now the thing I have to figure out is how to input my file correctly. I think I know how I am going to store it in memory (there might be a better way). I am thinking of either having one string for each chapter, or an array of strings of verses for each chapter, then I will have an array of pointers for each book pointing to those arrays, then I will have an array of pointers for the books pointing to the array of chapters.

The only thing I really have to figure out is this. I store the location of the chapters in the header, with four bytes per chapter. Therefore, 00 7C D6 25 would be the location of one of the chapters in the file. In decimal, this number is 8181285. I don't know how to input this and store it as an integer. Also the hex values are stored backwards, like 25 D6 7C 00.

>>it includes the Apocrypha
*snip* Hmm, where? It only has 66 books in it (I didn't bother comparing the texts, since that would be tedious), and I know the NIV old testament has 39 books, the NT has 27, for a total of 66...

>>I think I know how I am going to store it in memory
You could probably do that (it's only 4-5 mb), but I was actually thinking of just storing the verse locations in memory, then using seekg() to read the verses you need from the file when the time comes. That would spare you a lot of loading time (20-30 seconds on my computer).

Actually I think I was wrong about the ASV bible. It has 66 chapters and I couldn't find any keywords from the Apocrypha in it. I guess it's just worded differently and it threw me off.

>>I guess it's just worded differently
Different translation? ;)

Anyhoo, back to my own converter prog... having tons of fun with nested classes and inherited functions that are probably unneccessary :D

Hey I got the console version done. Some of the code is a little messy, and I have a little tweaking to do, but it works well. Try it!

You will need to download the bible text here and run the makebibledb program with that file in the same folder to make the Bible file.

I'm going to make a graphical version in the near future.

Hey yeah, I made one too. It's pretty simple, doesn't let you do searches or take notes or anything, but you can just type in a passage (i.e. "Amos 1:2") and it will display it. The main program is DigiBible, and the converter program is BFC (Bible FormatConvert). You can download the bible files for conversion from here.

I'll edit this post when I've had a look at yours.

**EDIT**
Ok, had a look at your code. Just a few small things I'd like to point out...
1) If this is C++, why use printf, malloc, free, FILE instead of cout, new, delete, ifstream?
2) A book <= 0 still counts as valid, and same with chapter ;)
3) The Verse destructor has a memory leak - you forgot the [] after delete :)
4) _BIBLESTRUCTURES_H_ is bad. According to the standard, anything with an underscore in front is reserved... so just knock off the front _ and you should be fine.

Other than that, I can't spot anything to really nag you about (although you should probably try to use the standard C++ library instead of the C versions). Great job so far!

Next, I'll have to download the bible file and do a running test... brb

**EDIT2**
Err, I downloaded the KJV bible and all, and followed your instructions, but when I run the makebibledb program, it doesn't work (it flashes across the screen for 1ms, and kjv.bbl appears in the folder, but kjv.bbl contains no data).