[C con Clase] ¿Que es mas recomendable ? (punteros)

[David A. Capello]

Sí, es legal que un puntero esté fuera de su rango
siempre y cuando no hagas referencia al valor que
apunta. Ej. El siguiente código es completamente
legal:

#include <iostream>

int main()
{
   char *p = "Hola";
   p--;

   // ... <-- Si hacemos *p ahora, eso es un acceso ilegal a memoria

   std::cout << *++p;
   std::cout << *++p;
   std::cout << *++p;
   std::cout << *++p;
}

La STL hace algo parecido con los iteradores.
{
   basic_string<char> s;
   s.push_back('H');
   s.push_back('o');
   s.push_back('l');
   s.push_back('a');
   cout << s << endl;
   int c = 0;
   for (basic_string<char>::reverse_iterator it = s.rbegin(); it !=  
s.rend(); ++it) {
     *it = '0'+c++;
   }
   cout << s << endl;
}

Da como resultado:

   Hola
   3210

Lo que es lo mismo que:
{
   char *s = new char[5];
   s[0] = 'H';
   s[1] = 'o';
   s[2] = 'l';
   s[3] = 'a';
   s[4] = 0;
   cout << s << endl;
   int c = 0;
   for (char *it = s+strlen(s)-1; it != s-1; --it) {
     *it = '0'+c++;
   }
   cout << s << endl;
}

Fijate como el puntero "it" queda en la posición "s-1" (que
no es accesible), al igual que un iterador STL en el posición
"rend()" (la cual tampoco es accesible).

Finalmente, acá te doy otras alternativas a tu código:
...
{
   int nPosicion = 0;
   while (*pCadena != 0) {
     if (*pCadena++ == cbCaracter)
       return nPosicion;
     nPosicion++;
   }
   return -1;
}
...
{
   return strchr(pCadena, cbCaracter);
}
...
{
   char *p = pCadena;
   while (*p != 0 && *p != cbCaracter) ++p;
   return *p != 0 ? p - pCadena: -1;
}

P/D: Parece ser que estás devolviendo 1 si está en la primera posición,
      en ese caso, deberías sumarle uno a todas las alternativas que
      te dí.

-- 
http://www.davidcapello.com.ar/

On Mon, 20 Nov 2006 18:37:54 -0300, rodolfo rosso paz  
<rodolforossopaz en hotmail.com> wrote:
> Hola a todos, gracias por atender mis consultas, quisiera saber si
> cualquiera de estas dos opciones
> es válida o si una es preferible a la otra, las he probado y las dos
> funcionan, pero a lo mejor
> una no es muy correcta, por estar manipulando posiciones de memoria con
> datos desconocidos.
>
> /* Funcion : BuscaCaracter
>     Recibe un puntero a char y un char
>     devuelve la posision de encuentro o -1 si no encuentra */
>
> int BuscaCaracter(char* pCadena, char cbCaracter)
> {
>     int nPosicion = 1;
>
>     // ¿ que es mejor ? ¿esto?
>     while(*pCadena   &&   *pCadena++  !=  cbCaracter)   nPosicion++;
>     return((*pCadena   ||   *(pCadena-1) == cbCaracter) ?  nPosicion  :
> -1);
>
>     // ¿o esto?  ¿ es valido retroceder una mas del limite de pCadena,
> mientras no le vaya a
>                         hacer ninguna modificación, o no es lícito  ?
>     pCadena--;
>     while(*++pCadena && *pCadena != cbCaracter) nPosicion++;
>     return(*pCadena ? nPosicion : -1);
> }