¿Usos comunes para los indicadores?

Question

Soy un estudiante de programación con dos clases en C#, pero estoy tomando mi primera clase en C++, y por lo tanto estoy expuesto a punteros.

Sé cómo funcionan, y la forma correcta de usarlos, pero me pregunté sobre algunas de las formas en que los programadores profesionales usan punteros en sus programas.

Entonces, ¿cómo se utilizan los punteros? ¿O usted?

Esto me ayudará a comprender algunas aplicaciones prácticas para los punteros, ¡así que gracias!

Answer 1

En cualquier momento utilizaría una referencia en C#. Una "referencia" es solo un puntero con elegantes bolsas de aire de seguridad a su alrededor.

Uso los punteros una vez cada seis líneas en el código de C++ que escribo. En la parte superior de mi cabeza, estos son los usos más comunes:

• Cuando necesito crear dinámicamente un objeto cuya vida excede el ámbito en el que fue creado.
• Cuando necesito asignar un objeto cuyo tamaño es desconocido en tiempo de compilación.
• Cuando necesito transferir la propiedad de un objeto de una cosa a otra sin copiarlo (como en una lista vinculada/montón/lo que sea de estructuras realmente grandes y caras)
• Cuando necesito referirme al mismo objeto de dos lugares diferentes.
• Cuando necesito cortar una matriz sin copiarla.
• Cuando necesito escribir directamente en una región específica de la memoria (porque tiene asignada IO de memoria).

Answer 2

Si tiene algo de tiempo en sus manos para leer un libro, le recomendaría leer The C Programming Language que hace un uso intensivo de los indicadores.

Un ejemplo sencillo de una función estándar:

/* strlen: return length of string s */ 
int strlen(char *s) { 
    char *p = s; 
    while (*p != '\0') p++; 
    return p - s; 
} 

Answer 3

Para estáteras, que ellos utilizan en su data structures, como lista enlazada, etc. en cualquier lugar que necesita asigna dinámicamente la memoria, es decir, la memoria que usted don' t saber el tamaño de en tiempo de compilación, utilizará un pointer.

Answer 4

Parte 1 de 2

punteros se requiere a menudo para interconectar con bibliotecas de C cuando los datos necesita ser pasado a una API existente. Este mecanismo no se limita a los sistemas "heredados", los ejemplos modernos incluyen OpenGL, DirectX y Win32.

a continuación es un ejemplo de OpenGL: glVertexPointer (int, float, int, float *) toma un puntero flotante como primer argumento.

GLfloat vertices[] = {...}; // 24 of vertex coords 
... 
// activate and specify pointer to vertex array 
glEnableClientState(GL_VERTEX_ARRAY); 
glVertexPointer(3, GL_FLOAT, 0, vertices); 

// draw a cube 
glDrawArrays(GL_QUADS, 0, 24); 

// deactivate vertex arrays after drawing 
glDisableClientState(GL_VERTEX_ARRAY); 

en lugar de utilizar una matriz definida estáticamente que estaría bien para hacer lo siguiente:

Glfloat *vertex = new GlFloat[24]; 
... 
glVertexPointer(3, GL_FLOAT, 0, vertices); 
... 
delete [] vertex. 

o si desea utilizar std :: vector

std::vector<Glfloat> vertex; 
vertex.resize(24); 
... 
glVertexPointer(3, GL_FLOAT, 0, &vertices[0]); 
... 

---

Parte 2 de 2

Los punteros a objetos y punteros a función son útiles para definir la función de miembro estático que necesita operar en una instancia específica de una clase. Este idioma aparece en los mecanismos de devolución de llamada.

class foo { 
    ... 
    public: 
    static int s_callback0(void* obj){ 
     return (foo*)(obj)->callback0(); 
    } 
    int callback0(){ 
     ... 
    } 
    ... 
}; 

class callbackAPI { 
    public: 
    int setCallback(int(*fn)(void*),void* context){ 
     m_fn(fn); 
     m_context(context); 
    } 
    void run(){ 
     m_fn(m_context); 
    } 
    private: 
    int(*m_fn)(void*); 
    void *m_context; 
}; 

main { 
    foo f; 
    callbackAPI cb; 
    cb.setCallback(foo::s_callback0,f); 
    cb.run(); 
} 

Si tiene control de callbackAPI se pueden lograr resultados similares con herencia y plantillas. Los ejemplos anteriores demuestran una forma de trabajar con un callbackAPI proporcionado por una tercera parte cuando se requiere para proporcionar un puntero a la función.