Dynamic and continuous array

You can always dynamically create contiguous homogeneous storage of a certain type from the heap using the new operator

Type *pType = new Type[size](initial_value)

In Order to delete the storage, you need to explicitly invoke the array delete operator

delete[] pType

But, when you say, and my biggest performance issue is the vector [] operator., I doubt. Did you profile the retail version of your code? How do you know the vector subscript is your performance bottleneck?

std::vector has enough performance to use in production. It is used for solving problems on programming contests. Maybe, you forget to compile into release?

Also, you can use new and delete operators.

To free allocated memory use free(void *ptr) function.

In C you create a 1-D array with

int *ptr=NULL;
int num_elements = 0;
printf("how many elements?\n");
if(scanf("%d", &num_elements)==1) {
  ptr = malloc(sizeof(int)*num_elements);
  if(ptr == NULL) {
    printf("unable to allocate %d elements\n", num_elements);
    exit 0;
  }
} 

and when you're done, you call

free(ptr);

Make sure you call it only once! Some people will do

if( ptr != NULL ) {
  free(ptr);
  ptr = NULL;
}

as defensive coding - prevents accidentally freeing it twice.

If you are using C++, using malloc is probably a poor (inferior) idea.

int length;
cin >> length;

MyType * array = new MyType[length];

Then to delete,

delete[] MyType;