It's probably killed by kernel's oom killer. dmesg should contain information about it. Sorry, but you may need to redesign your algorithm.

You almost certainly lack a swap partition, or you have some other utility monitoring the amount of available free memory, and therefore your program is killed because it consumes too much memory, up to the point that there is no free ram left.

You can use htop or conky to have a clear view of the issue.

If instead you had a swap partition then your system would attempt to swap the memory from/to the disk, and this would most likely freeze it. This is a much worse scenario, because in most cases the only action that you can take to get the system back working is to reboot it: in my experience, when the system freezes then it no longer responds to any keyboard input.

On my system it takes 2m26s for your executable to fill over 50% of the available 8GB of RAM, not counting the additional 32% that is occupied by the other running programs.

You might want to use a memory leak profiling tool (e.g. valgrind) to check for potential leaks, or simply inspect the source code manually. If you can't reduce its memory footprint, then your only option is to look for a much more powerful machine with a larger pool of RAM.

There are multiple issues with your code:

• system(3) does NOT return PID of child process, but instead waits for it to exit, and returns its exit code. You need to use the traditional fork+exec approach.
• With child PID available, it's easier to call kill(2) than kill(1)
• Better add sleep in a dead loop waiting for input. This reduces CPU load and your electricity bill.

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

pid_t child_id;

void ctrl_C(int sig){
    kill(child_id, 9);
    printf("\n You pressed Ctrl + C,Good Bye \n");
    exit(0);    
}



int main(){
    printf("I am Programmer \n");
    pid_t child_id = fork();
    if (child_id == 0) {
        execlp("gnome-terminal", "gnome-terminal", "--", "vi", "abcd.txt", NULL);
        return 255;
    }
    signal(SIGINT,ctrl_C);
    while (1) {
        sleep(1);
    }
}

In C++, a float is a single (32 bit) floating point number: http://en.wikipedia.org/wiki/Single-precision_floating-point_format

which means that you are allocating (without overhead) 3 840 000 000 bytes of data.

or roughly 3,57627869 gigabytes..

Lets safely assume that the header of the vector is nothing compared to the data, and continue with this number..

This is a huge amount of data to build up, Linux may assume that this is just a memoryleak, and protect it self by killing the application:

https://unix.stackexchange.com/questions/136291/will-linux-start-killing-my-processes-without-asking-me-if-memory-gets-short

I don't think this is an overcommit problem, since you are actually utillizing nearly half the memory in a single application.

but perhaps.. consider this just for fun.. are you building an 32bit application? you are getting close to the 2^32 (4Gb) memory space that can be addresssed by your program if it's a 32 bit build..

So in case you have another large vector allocated... bum bum bum

The line kill(atoi(argv[1]), SIGKILL); sends a SIGKILL signal to the process with the specified ID; this should cause it to terminate. The atoi(argv[1]) part converts the string from the command-line parameters into an integer.

For the rest, I recommend picking up a beginner's guide to C.

Originally posted at Unix.stackexchange.com, but I can't close vote it to that answer, so this is a copy:

The “kill” meaning of Ctrl+C is very old, I think even older than Unix. Wikipedia traces it back to TOPS-10, which would date it from the late 1960s. The article explains why Ctrl+C was a reasonable choice: in ASCII, which was published in 1963, the corresponding character is ETX, end-of-text. Lacking a character meaning “stop”¹, a character meaning “this segment of input is over” was a reasonable choice to mean “stop the current processing”.

The “copy” meaning of Ctrl+C comes from Xerox PARC, the inventors of copy-paste in its modern form (and most other fundamentals of graphical user interfaces). I don't know exactly when that was, but it must have been the late 1970s. This thread on User Experience Stack Exchange discusses the choice of key bindings; C for copy makes a lot of sense.

There was little reason for PARC to reject Ctrl+C for copy on the basis of the existing meaning in TOPS-10 and Unix terminals. Operating systems and applications were more diverse then, and far fewer people used computers; there was no opportunity nor call for a single standard for key bindings across all applications. Other uses for Ctrl+C in popular applications include page-down in WordStar² and mode-specific command in Emacs. All of these were designed independently, for applications with often different requirements, running in different environments.

You can configure the terminal key bindings with the stty command. The terminal bindings are active when the terminal is in cooked mode³. For example the command stty intr ^G sets the character that sends a SIGINT signal to Ctrl+G instead of Ctrl+C. The ^G character is BEL in ASCII; when sent to a terminal, it means “ring the bell”. It's the character that Emacs uses for “interrupt the current operation” (rationale: the application sends BEL to the user via the terminal to interrupt the user; the user sends BEL to the application via the terminal to interrupt the application). It doesn't have a standard meaning when sent to a terminal.

Most shells provide line editing features, so they set the terminal to raw mode. So do full-screen text mode applications. You may need to configure these applications to recognize Ctrl+G instead of Ctrl+C, and some may have non-configurable key bindings. So changing the interrupt character may or may not be practically doable depending on which applications you use.

Another approach could be to configure your terminal to change the byte sequence that it sends for the Ctrl+C keychord, or make it send nothing and instead perform a copy operation. You would also choose a different keychord to send Ctrl+C (if you have a non-laptop PC keyboard, you could use the out-of-the-way Pause/Break key). Not all terminals can be configured in this way.

¹ Ctrl-S (XOFF) means stop, but it's addressed to the terminal, not to the application. ² Next to Ctrl+X for next-line, with Ctrl+E and Ctrl+R for previous-line and page-up; these keys were chosen due to their placement on a QWERTY keyboard. ³ Nitpick: cooked mode is a set of terminal settings, including the interpretation of several characters including one that sends an interrupt signal.

kill(2) is the system call to send a signal to a process there isn't an equivilent to the killall utility.

An easy way to do this in C would be to invoke killall from your C program, using the system(3) library function or possible popen(3).

Alternatively you could read the manual page about the /proc pseudo file system and search for the command names and find the pids yourself.

man 2 kill
man 3 system
man 3 popen
man 5 proc