long AnsiString::pos(const char* plainString) const {
const size_t patternLength = strlen(plainString);
if (patternLength == 0) return -1;

size_t stringLength = count;
int partialMatch[patternLength]; // int* partialMatch = new int[patternLength];

KMPBuildPartialMatchTable(plainString, partialMatch);

int currentStringCharacter = 0;
int currentPatternCharacter = 0;
while (currentStringCharacter < stringLength) {
    if (currentPatternCharacter == -1) {
        currentStringCharacter++;
        currentPatternCharacter = 0;
    }
    else if (items[currentStringCharacter] == plainString[currentPatternCharacter]) {
        currentStringCharacter++;
        currentPatternCharacter++;
        if (currentPatternCharacter == patternLength) return currentStringCharacter - currentPatternCharacter;
    } else {
        currentPatternCharacter = partialMatch[currentPatternCharacter];
    }
}

// delete(partialMatch);

return -1;
 }

Recibo un error en la implementación de este método de clase usando Visual C ++.

int partialMatch[ patternLength ] ; // expression must have a constant value 

(Estoy usando VS en otro idioma para que pueda encontrar algunas diferencias).

Declaré patternLength como una constante como puedes ver. Se comenta una solución en el ccode pero no quiero usar la asignación dinámica de memoria. Alguna idea ?

-1
Julian Estefan 8 sep. 2018 a las 20:11

3 respuestas

La mejor respuesta

Los tamaños de matriz deben conocerse en el momento de la compilación.

Una variable const no garantiza eso. El calificador const garantiza que la variable no se pueda modificar una vez que se inicializa.

Es posible que el valor de la variable const se conozca en tiempo de compilación. Si un compilador puede detectar eso, entonces la variable se puede usar para definir el tamaño de una matriz.

Más a menudo, el valor de una variable const no se conoce en tiempo de compilación. Se inicializa con un valor en tiempo de ejecución, que no se puede cambiar después de inicializar la variable. Eso no lo hace apto para usar para definir el tamaño de una matriz.

Si desea poder usar la variable en tiempo de compilación, use constexpr en su lugar. El compilador hará todo lo posible para evaluar el valor en tiempo de compilación. Fallará si el valor de la variable no se puede evaluar en tiempo de compilación.

4
R Sahu 8 sep. 2018 a las 17:28

El tamaño N en una declaración de matriz T[N] debe ser una expresión constante en tiempo de compilación.

std::size_t const a{42}; // is one,

std::size_t foo{std::rand() % 100};
std::size_t const b{foo}; // is not, because it depends on foo
2
Swordfish 8 sep. 2018 a las 17:34

Marcar algo const no lo convierte en una expresión constante per se . Hace que sea de solo lectura. El lado derecho de su estado de cuenta debe cumplir con función constexpr, que los requisitos de { La expresión {X1}} no. Puede hacer su propia función que se evalúa durante el tiempo de compilación:

constexpr size_t constexprlength(const char* s) {
    return strlen(s);
}

Y usar eso en su lugar:

constexpr size_t patternLength = constexprlength(plainString);
int partialMatch[patternLength];

Los VLA y las matrices de caracteres son malvados . Utilice std::vector y std::string en su lugar.

0
Ron 8 sep. 2018 a las 17:34