#include <iostream>
using namespace std;

const int size = 1024;

void upCaseCString( char *source, char *target )
{
   while( *source != NULL )
   {
     if( (*source >= 'a' ) && (*source <= 'z') )
       *target++ = *source++ - 32;
     else
       *target++ = *source++;
   }
}

int main()
{
  char data[ size ] = "";
  char upCaseCopy[ size ] = "";
  int N = 0;

  cin >> N;
  
  for( int i = 0; i < N; i++ )
  {
    cin >> data;
    cout << data << " : ";

    upCaseCString( data, upCaseCopy );

    cout << upCaseCopy << endl;

    for( int i = 0; i < size; i++ )
    upCaseCopy[ i ] = NULL;
  }
  return 0;
}

#include <iostream>
using namespace std;

//
// Why is the following declaration global? Its value is only needed in
// main(), where it is used as the size of the declared arrays.
//
// It may be perfectly appropriate to define global constants for
// things like Pi or Planck's constant, but not for general use of
// user variables.
//
// Gratuitous use of globals is generally frowned upon, although
// it does no harm here, and doesn't really add any confusion
// as to the intent of the programmer or create any real difficulty
// in this simple (and short) program.
//
const int size = 1024;

//
// My criticism of the following function is that it depends on something
// in the calling function to make sure that there is a terminating
// zero byte at the end of the copied string. I think that a function
// that copies a C-style "string" should also supply the terminating
// zero byte to the target.
//
void upCaseCString(char *source, char *target)
{
    // Note that NULL is a pointer, but *source is a char.  I don't
    // think it it is a particularly good style to compare a pointer
    // to a char. I believe that any of the following
    // would be preferable:
    //
    // while (*source != '\0') // Emphasizes that *source is a char
    //   or
    // while (*source != 0)    // Perfectly acceptable since it's an integer data type
    //   or
    // while (*source)         // Exactly equivalent to the previous statement
    // 
    while (*source != NULL) {
        if ((*source >= 'a') && (*source <= 'z'))
            //
            // Here we are assuming that 'a' - 'z' are contiguous
            // and 'A' - 'Z' are contiguous, as they are in English (ASCII),
            // I think a better style for the translation would be something like
            //
            // *target++ = *source++ - ('a' - 'A')
            //
            // This eliminates dependence on the mysterious magic number '32'
            // to translate lower to upper. For ASCII, 'a' - 'A' is, indeed,
            // equal to 32, but why should the programmer (or his/her boss)
            // depend on memory or some table somewhere to verify this?
            //
            *target++ = *source++ - 32;
        else
            *target++ = *source++;
    }
    // I strongly believe that the function should append the zero byte.
    // Some people might use a slightly different loop that copies
    // everything up to and including the zero byte.  Putting it here,
    // after the loop, has the advantage of making sure that the reader
    // knows its intent.
    // *target = 0;
}

int main()
{
    //There is absolutely no reason to initialize the data array
    char data[size] = "";
    //
    // If the function were implemented properly, and input
    // validation for N were performed, there would be
    // no reason to initialize the target array
    //
    char upCaseCopy[size] = "";
    //
    // If input validation were performed for getting the value
    // from the user, there would be absolutely no reason to 
    // initialize N.  Furthermore conventional style uses upper 
    // case for #defined constants or other manifest constants.  
    // Lower case is the norm for user variables
    //
    int N;

    // There is no test to see whether N is an valid number. If
    // the user enters a non-numeric quantity, the input stream
    // enters the "fail" state and further input is not possible.
    //cout << "Enter a positive integer: ";
    cin >> N;
    //if (cin.fail()) {
    //    cout << "Invalid entry." << endl;
    //    return 0;
    //}

    for (int i = 0; i < N; i++) {
        //
        // Using cin>> for input to an array of chars is inexcusably
        // unsafe, since there is no way to prevent a "buffer overrun"
        // It is never safe to use cin>> for an array of chars.
        // On the other hand, maybe you haven't been exposed to
        // other ways, so this is what you were supposed to do
        // for this assignment.  I just thought I would mention it.
        //
        cin >> data;
        cout << data << " : ";

        upCaseCString(data, upCaseCopy);

        cout << upCaseCopy << endl;
        //
        // If the function were implemented properly, the following
        // wouldn't be necessary.  I don't think that superfluous
        // code is ever a good thing
        //
        for (int i = 0; i < size; i++)
            //
            // Note that NULL is a pointer, and setting a char
            // equal to a pointer is probably not a good idea. Maybe
            // it will do what you want, but it's bad form, in my
            // opinion.
            //
            // If you do need to do this, then I think either of
            // the following would be preferable:
            //
            // upCaseCopy[i] = '\0'; // Emphasizes that it's a char
            //    or
            // upCaseCopy[i] = 0;   // Perfectly acceptable, since zero is converted to a char
            //
            upCaseCopy[i] = NULL;

    }
    return 0;
}

while (*source != '\0') // Emphasizes that *source is a char
      or
while (*source != 0)    // Perfectly acceptable since it's an integer data type
      or
while (*source)         // Exactly equivalent to the previous statement
    
while (*source != NULL) 

    while (*source) {
        if ((*source >= 'a') && (*source <= 'z')) {
            *target++ = *source++ - ('a' - 'A')
        }
        else {
            *target++ = *source++;
        }
    }
    *target = 0; // Append the terminating zero byte

 while (*source) 

while( *source != 'EOF' )

#include <iostream>
#include <fstream>
using namespace std;

void encrypt( char *, char *, int );

int main()
{
   const int size = 1024;
   char encryptCopy[ size ];
   char data[ size ];
   int key;
 
   ifstream fin( "input.txt" );
   ofstream fout( "output.txt" );
    
   if( fin.fail() )
   {
     cout << "Error: cannot open file" << endl;
     return -1;
   }

   cout << "Enter encryption integer key: ";
   cin >> key;

   if( !cin.good() )
   {
     cout << "Error: input must be an integer" << endl;
     return -1;
   }

   fin.get( data, size, 0 );
 
   encrypt( data, encryptCopy, key );
   
   fout << encryptCopy << endl;

   fin.close();
   return 0;
}

void encrypt( char *source, char *target, int key )
{
  while( *source )
    *target++ = ( *source++ ) - key; // encryption process 
  
  *target = '\0';
}

#include <iostream>
#include <fstream>
#include <iomanip>

using namespace std;

void encrypt( char *, char *, int );

int main()
{
   const int size = 1024;
   char encryptCopy[ size ];
   char data[ size ];
   int key;
 
   ifstream fin( "input.txt" );
   ofstream fout( "output.txt" );
    
   if( fin.fail() )
   {
     cout << "Error: cannot open file" << endl;
     return EXIT_FAILURE;
   }

   cout << "Enter encryption integer key: ";
   cin >> key;

   if( !cin.good() )
   {
     cout << "Error: input must be an integer" << endl;
     return EXIT_FAILURE;
   }
   cout << "You entered " << key << endl;

   fin.get( data, size-1, 0 );
   cout << "Number of chars read = " << fin.gcount() << endl;
   data[fin.gcount()] = 0;  // Note that fin.get() does not put the zero byte!

   cout << "data: <" << data << ">" << endl;
 
   encrypt( data, encryptCopy, key );

   cout << "strlen(data) = " << strlen(data)
        << ", strlen(encryptCopy) = " << strlen(encryptCopy)
        << endl << endl;;

   cout << " i   data[i]  int(data[i])    int(encryptCopy[i])" 
        << endl << endl;
   for (unsigned i = 0; i < strlen(data); i++) {
       cout << setw(2) << i;
       
       if (isprint(data[i])) {
               cout << setw(8) << data[i];
       }
       else {
           cout << hex << setw(6) << "0x"  << hex << setfill('0')
                << setw(2) << int(data[i]) << dec << setfill(' ');
       }

       cout << setw(12) << int(data[i])
            << setw(18) << int(encryptCopy[i]) << endl;
   }
   
   fout << encryptCopy << endl;

   fin.close();
   fout.close();
   return 0;
}

void encrypt( char *source, char *target, int key )
{
  while( *source )
    *target++ = ( *source++ ) - key; // encryption process 
  
  *target = '\0';
}