Large number stored as vector, increase performance
Congratulations on having code ready to review!  Here are some thoughts on how you could improve this:


You have tagged this code as both C and C++. To me, this looks purely like C code. If so, please edit the tags. If this needs to work as both C and C++ code, you'll want to specify what other constraints apply. 
C code is generally written using snake_case for function names. For a module of functions operating on a shared data type, a short prefix is often used. Since you are calling your objects "LongNum", I suggest you rename your functions to use a prefix of lnum_ or lngn_ or lnm_ or something.

char Add( char *Vin1, char *Vin2, char *Vout, unsigned N ) {...}


becomes

char lnum_add(char * ln1, char *ln2, char *lnout, unsigned N) {...}

Creating a LongNum requires allocating memory. That operation can and should be part of the library by default. (You might want to code a function for "initialize longnum from user-supplied memory" but I doubt you'll need it.) So you should not be doing malloc() or free() calls directly, but instead you should be calling lnum_new_random() and lnum_delete().
I don't see a reason to avoid the C++ naming scheme, so I suggest calling your creation/allocation functions new and your free functions delete.
Related to (4), I believe a good library should be able to create objects in various ways. Particularly, a random value, a fixed value like zero or one, an arbitrary integer value, a value from a double, and possibly values from strings, and/or values from an input stream. 

lnum_new_random(unsigned max_digits)
lnum_new_zero(unsigned max_digits)
lnum_new_from_int(unsigned max_digits, long long init_val)
lnum_new_from_unsigned(unsigned max_digits, unsigned long long init_val)
lnum_new_from_double(unsigned max_digits, long double init_val)
lnum_new_from_string(unsigned max_digits, const char * str)
lnum_new_from_file(unsigned max_digits, FILE * input)
lnum_new_from_lnum(LNUM original)

Instead of passing a parameter N around to specify the maximum length of the data type, why not build a struct to store the information.

For starters, you could define a struct with your max_digits value and the pointer to the start of the digits buffer. A more advanced version would eliminate the pointer and allocate the digit buffer immediately after the max_digits value. 

struct LNUM {
    unsigned max_digits;
    char * digits;
};


By doing this, you could decide whether passing the objects as pointers or struct values made more sense. So you would want a named type that you control, rather than just letting the user pass around a char * pointer:

typedef struct LNUM LNUM;     // if struct LNUM includes digits as pointer
typedef struct LNUM * LNUM;   // if struct LNUM includes digits as array

Your PrintNumber function provides the only way to extract the number. And it hard-codes the radix, the output stream, and the format. I'd suggest writing a function to emit an LNUM onto a stream, and one to write an LNUM into a string buffer in a provided radix.

size_t lnum_formatted_length(LNUM ln);
void lnum_format_to_string(LNUM ln, char * buffer, size_t max_chars);

Instead of treating N as a constant, would it be so wrong to have N dynamically computed? Your multiplication function returns two numbers, "low" and "high", each of size N. Why not simply return a single number that has the correct size as determined by your multiply function? Maybe it needs more digits, maybe it doesn't.