title: Pointers and fixed size buffers may only be used in an unsafe context
body: <p>I have 2 functions within a class and getting error on the call for ParseBits() function i.e. "<code>int num_elements = ParseBits(bits, buffer);</code>" because of the "buffer" arguement I am passing "<code>public int ParseBits(string bits, int* buffer)</code>":</p>
  
  <p>Function 1:</p>
  
  <pre><code>public float AssignFitness(string bits, int target_value)
          {
  
     //holds decimal values of gene sequence
     int[] buffer = new int[(VM_Placement.AlgorithmParameters.chromo_length / VM_Placement.AlgorithmParameters.gene_length)];
  
     int num_elements = ParseBits(bits, buffer);
  
     // ok, we have a buffer filled with valid values of: operator - number - operator - number..
     // now we calculate what this represents.
     float result = 0.0f;
  
     for (int i=0; i &lt; num_elements-1; i+=2)
     {
        switch (buffer[i])
        {
           case 10:
  
              result += buffer[i+1];
              break;
  
           case 11:
  
              result -= buffer[i+1];
              break;
  
           case 12:
  
              result *= buffer[i+1];
              break;
  
           case 13:
  
              result /= buffer[i+1];
              break;
  
        }//end switch
  
     }
  
     // Now we calculate the fitness. First check to see if a solution has been found
     // and assign an arbitarily high fitness score if this is so.
  
     if (result == (float)target_value)
  
        return 999.0f;
  
     else
  
        return 1/(float)fabs((double)(target_value - result));
     //   return result;
  }
  </code></pre>
  
  <p>Function 2:</p>
  
  <pre><code>public int ParseBits(string bits, int* buffer)
          {
  
              //counter for buffer position
              int cBuff = 0;
  
              // step through bits a gene at a time until end and store decimal values
              // of valid operators and numbers. Don't forget we are looking for operator - 
              // number - operator - number and so on... We ignore the unused genes 1111
              // and 1110
  
              //flag to determine if we are looking for an operator or a number
              bool bOperator = true;
  
              //storage for decimal value of currently tested gene
              int this_gene = 0;
  
              for (int i = 0; i &lt; VM_Placement.AlgorithmParameters.chromo_length; i += VM_Placement.AlgorithmParameters.gene_length)
              {
                  //convert the current gene to decimal
                  this_gene = BinToDec(bits.Substring(i, VM_Placement.AlgorithmParameters.gene_length));
  
                  //find a gene which represents an operator
                  if (bOperator)
                  {
                      if ((this_gene &lt; 10) || (this_gene &gt; 13))
  
                          continue;
  
                      else
                      {
                          bOperator = false;
                          buffer[cBuff++] = this_gene;
                          continue;
                      }
                  }
  
                  //find a gene which represents a number
                  else
                  {
                      if (this_gene &gt; 9)
  
                          continue;
  
                      else
                      {
                          bOperator = true;
                          buffer[cBuff++] = this_gene;
                          continue;
                      }
                  }
  
              }//next gene
  
              //   now we have to run through buffer to see if a possible divide by zero
              //   is included and delete it. (ie a '/' followed by a '0'). We take an easy
              //   way out here and just change the '/' to a '+'. This will not effect the 
              //   evolution of the solution
              for (int i = 0; i &lt; cBuff; i++)
              {
                  if ((buffer[i] == 13) &amp;&amp; (buffer[i + 1] == 0))
  
                      buffer[i] = 10;
              }
  
              return cBuff;
          }
  </code></pre>
  
  <p>I am getting 2 errors for this functions on the highlighted lines:</p>
  
  <pre><code>Error 1: The best overloaded method match for 'VM_Placement.Program.ParseBits(string, int*)' has some invalid arguments
  
  Error 2: Pointers and fixed size buffers may only be used in an unsafe context
  </code></pre>