"C" Input Overloading

Use the function kbhit() to sense if key was pressed and then read the key hit using getch() function. finally store the chanracter into a very large array pointed by your pointer and increment counter. You can store as big as gegabyte character array. If you know nothing about C or C++ then get a small book on it and read few examples.

I'm going back many years, but...

Welcome to the world of 90% of the "security holes" in commercial software.

Put your input - using getch() into a fixed length array, one character at a time. When your pointer reaches the array size DO NOT INCREMENT it any more. So typing the alphabet into an 8-character array results in abcdefgz. Alternately you can be clever and start the pointer over at 0 when it reaches it's max, so your above array would read yzstuvwx. Being really smart you could push everything down one once the end was reached and your array would hold the last n characters typed. The example would be stuvwxyz.

NEVER let anyone talk you into making the input area 'large enough for expected worst cases' without a finite limit and pointer control. Let me repeat that: NEVER!!!

Another way is to look for duplicated characters. If the only thing you are trying to trap is a single key being held down then all the characters will be the same. Check the last n characters and if they are identical ditch the input after the first of the replicated characters. You will need to set n to allow for the sort of know duplicated characters that you will normally see. Also don't forget about blank spaces etc. when calculating the value for n as they may occur in large numbers.

You should start by posting which compiler you use and which OS you use it on. There is a world of a difference in programming for DOS than Windows XP or the likes.

I agree with the rest, there are good but complex ways to do this, but kbhit() and getch() are an easy way out. kbhit() is a function wich will let you know when the keyboard is hit and getch() will get a character from the keyboard buffer, thus keeping it clean. Try it and come back if you need more answers.

Regards.

Alex. (also from electronics)

another good way is to keep two pointers and a round buffer or end to end joined memory. pointer one at the start of the buffer and pointer two at the filled position. if you overload the buffer then move the start pointer, which will eat away the old data. This way you will keep the last data you entered. This is like forgetting your previous months time table and keeping only current one. If data is less then you will have all of it.

Thanks for the replies, tho sadly I dont understand about pointers yet, as im only a few weeks into the corse, so im a little confused still.

Here is a sample of my prog so far...

do
{
system("cls");
printf("\n\nPlease select the first frequency in Hz : ");
scanf("%s",bufferfreq1);
fflush(stdin);
freq1 = (float)atof(bufferfreq1);

}
while (freq1 <= 0 || freq1 >= 1000000001);

ect-ect-..

could someone possibly show me as a example how do use the functions suggested?

I have books and books on "C" tho the way they all explain their funactionality is too differcult for me to grasp yet.

Im using "bloodshed" Dev-C++ as the writer+complier, and im on XP.

Thanks again.

It's all about this line: "scanf("%s",bufferfreq1); "

Somewhere bufferfreq1 is declared, maybe like this:

char bufferfreq1[100];

So, you could safely handle upload 100 (or sizeof(bufferfreq1)) chars of input and the terminating '\0'. You need some way to tell scanf not to put more than 100 chars into bufferfreq1.

You should read about scanf formats and you'll see that there are "width" options. You can use them to constrain the length of an input field. A google search on "scanf width" will lead you to the right place.

Good luck!

scanf() is not a good function as it requires <CR> to respond.

It also will have problem with 1234<BS><BS><BS><BS><CR>

actually I have pressed 9 keys and will get NULL from scanf() function. I think getch() is much better.

any way as he is just starting so

say

main()

{

char mydata[1000];

maydata << cin;

cout << mydata;

}

The technique that Shyam described is used a lot and your bound to come across it so I thought I would explain it to you in more detail. For the explanation refer to the diagram below:

So here is how it works. First you assign a table that will be used as the buffer (represented by the boxes), in this case 16 locations ling. Now you have two pointers that point to locations in the buffer, a write pointer (blue arrow) and a read pointer (red arrow).

Every time a character is received it is placed in the location that the write pointer points to and the pointer value is incremented by 1. In this case the character I has been written to location 08 so the Write pointer will be incremented and the next character will go in location 09. Whenever a pointer gets to goes past location 15 the pointer resets and goes back to 00.

Now when you wish to read the data and process it you read it from the location the Read Pointer (red arrow) points to. In this situation location 04 which contains the character E. The read pointer is then incremented ready to read the contents of the next location. As with the write pointer when it gets to 15 it resets back to 00.

After each read cycle you check to see if the values of the pointers are equal and if they are then there are no further characters to read from the buffer.

As you can see the buffer can never overflow but if the write pointer catches up with the reads pointer then you will loose the 16 characters that havn't yet been read. Because of this it is vitally important that you calculate the size of the buffers so that in normal operation the write pointer never catches the read pointer otherwise you will loose data. I have seen this happen with printers buffers and the result can be very confusing as the end of a document ends up being printed before the beginning.

I doubt this type of buffer will help you in this situation but I can guarantee that you will both come across and use this type of buffer many times when programming.

Dear Masu

Nice explanation indeed.

The actual buffer is like this one when partially filled.

when fully filled, it is only one location away. thereafter both pointers move together.

I call all start up software engineers See-in (cin) and See-out (cout) technologymen.

These functions sometime work in funnt way.

Try Borland C++ compiler for these.