Zeiger und Puffer fester Größe können nur in einem unsicheren Kontext

Ich habe 2 Funktionen, die innerhalb einer Klasse und immer Fehler auf der call-for-ParseBits () - Funktion, d.h. "int num_elements = ParseBits(bits, buffer);", weil der "Puffer" arguement ich bin vorbei "public int ParseBits(string bits, int* buffer)":

Funktion 1:

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 < 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;
}

Funktion 2:

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 < 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 < 10) || (this_gene > 13))

                        continue;

                    else
                    {
                        bOperator = false;
                        buffer[cBuff++] = this_gene;
                        continue;
                    }
                }

                //find a gene which represents a number
                else
                {
                    if (this_gene > 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 < cBuff; i++)
            {
                if ((buffer[i] == 13) && (buffer[i + 1] == 0))

                    buffer[i] = 10;
            }

            return cBuff;
        }

Bin ich immer 2-Fehler für diese Funktionen auf die markierten Zeilen:

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

Also, was ist Ihre Frage? deshalb bekommen Sie den Fehler? was Sie tun können, um Sie zu vermeiden? warum Sie nicht verwenden können, Zeiger in verwaltetem code oder etwas anderes? (wissen genau was Sie, was mit Hilfe macht es leichter zu helfen, als wenn wir zu erraten, wir könnten Recht und wir könnten nicht)
Was kann ich tun, um Sie zu vermeiden... ich denke, ich bin die übergabe der Argumente in ParseBits () - Funktion in eine falsche Art und Weise und daher bin ich immer noch ein Fehler "Argument 2: keine Konvertierung von 'int[]' to 'int*'"
Warum sind Sie mit Zeigern in den ersten Platz?

InformationsquelleAutor user1277070 | 2012-04-22

c#pointers

5

Vielleicht habe ich es verpasst, aber Sie scheinen nicht zu werden, etwas zu tun, die tatsächlich erfordert die Verwendung eines int*. Warum nicht einfach geben Sie einen int-array und ändern Sie die ParseBits Funktion Signatur:

public int ParseBits(string bits, int[] buffer)

und entfernen Sie die unsafe{ ... } Blöcke insgesamt.

InformationsquelleAutor Iridium
19

Müssen Sie schließen Sie die Funktion mit raw-Pointern in ein unsafe block.
```
unsafe 
{
 //your code
}
```
und wie rufe diese Funktion dann? dass diese Funktion unsicher entfernt "Zeiger und Puffer fester Größe können nur in einem unsicheren Kontext" Fehler, aber ich bin noch immer "Die beste übereinstimmung für die überladene Methode 'VM_Placement.Programm.ParseBits(string, int*)' hat einige ungültige Argumente" auf, die Funktion aufrufen.
Ich würde sagen, Sie hatte auch den Ruf Website Ihrer Funktion unsafe da es erfordert auch Zeiger.
Nopes hat nicht geklappt... ich denke, es ist weil of die Art von Argumenten bin ich vorbei... ich bin immer noch ein Fehler im argument übergeben Sie beim Aufruf ParseBits() "Argument 2: keine Konvertierung von 'int[]' to 'int*'"
in C# ein T[] (in deinem Fall int[]) ist nicht T*, die ist, warum Sie die Fehlermeldung erhalten

InformationsquelleAutor Tony The Lion
2

Ich hatte das gleiche problem, aber es war nicht gelöst alle anderen Antworten bis hier. Ich habe immer unterschiedliche Fehler.

Was auch immer Funktionen, Verwendung von unsicheren code müssen lediglich deklariert werden, mit der "unsicheren" keyword.

Zum Beispiel:
```
static unsafe void myFunction(int* myInt, float* myFloat)  
{
    //Function definition
}
```
Persönlich, ich habe versucht, dies zu tun, wenn Sie eine wrapper-Klasse.

Für Interessierte, es endete auf der Suche etwas wie dieses:
```
using System.Runtime.InteropServices;

namespace myNamespace
{
    public class myClass
    {
        [DllImport("myLib.so", EntryPoint = "myFunction")]
        public static extern unsafe void myFunction(float* var1, float* var2);
    }
}
```
Gibt es eine Menge information in der MSDN "Unsichere Code-Tutorial":

https://msdn.microsoft.com/en-us/library/aa288474(v=vs. 71).aspx

Ist es wohl Wert, gelesen zu werden, ich fand es ganz nützlich.

InformationsquelleAutor MD-7

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.