Comentarios en C#, C++, HTML, CSS3, Ensamblador, SQL Server y php

La forma de hacer comentarios en los lenguajes de programación es muy sencilla pero es diferente en cada uno de ellos veamos algunos ejemplos:

Comentarios en C# y C++:

En C# solo bastan dos diagonales seguidas.

//comentario

Un grupo de comentarios se inicia con una diagonal seguida de un asterisco y termina con un asterisco seguido de una diagonal.

/* Bloque de comentarios

Bloque de comentarios

Bloque de comentarios */

También cabe mencionar que en Visual Studio existe una forma de agrupar código para minimizarlo usando la sentencia región. A un lado aparecerá un cuadro con un signo de – para minimizar ese grupo de código.

#region nombre_del_codigo

//aquí va código

#endregion

Comentarios en SQL Server:

Cuando se tiene el código en SQL Server los comentarios se asignan con dos guiones medios seguidos.

--comentario

Comentarios en HTML:

Para HTML, debido a que usa etiquetas sus comentarios son igual a una etiqueta. Inician con un menor que (<) seguido de un signo de admiración (!) – le proceden dos guiones medios (--), se coloca el comentario o bloque de comentarios y se termina con dos guiones medios (--), se cierra la etiqueta con el mayor que (>).

<!--comentario-->

<!--bloque de comentarios

Bloque de comentarios

Bloque de comentarios -->

Comentarios en CSS3:

En CSS3 los comentarios o bloques de comentarios inician con una diagonal seguida de un asterisco y terminan con un asterisco seguido de una diagonal.

/* Comentario*/

/* Bloque de comentarios

Bloque de comentarios

Bloque de comentarios */

Comentarios en php:

Aquí los comentarios son con dos diagonales y un bloque con diagonal, asterisco, asterisco y diagonal.

//comentario

/* Bloque de comentarios

Bloque de comentarios

Bloque de comentarios */

Comentarios en Ensamblador:

Para este lenguaje basta un punto y coma.

;comentario

Pirámide cuadrada en Open GL

// piramide.cpp: define el punto de entrada de la aplicación de consola.

//

#include"stdafx.h"

//librería para utilizar operaciones matemáticas

#include<glut.h>

voidInicializacion(void);

voidDibuja(void);

int main()

{

       //inicio del boblebuffering para evitar parpadeo

glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);

//tamaño de la pantalla

glutInitWindowSize(600,600);

//posición de inicio de la pantalla

glutInitWindowPosition(0,0);

//título de la pantalla

glutCreateWindow("Pirámide cuadrada");

//llamado a inicialización

Inicializacion();

//llamado a dibuja

glutDisplayFunc(Dibuja);

//ciclo para pausar la pantalla

glutMainLoop();

return 0;

}

voidInicializacion(void)

{

       //matriz a modificar

glMatrixMode(GL_PROJECTION);

//resetear a la matriz a su estado por default

glLoadIdentity();

//se indica la perspectiva en que se verá

gluPerspective(70,1,0.1,100);

//matriz de transformacion

glMatrixMode(GL_MODELVIEW);

//permiyte trasladar un objeto en el espacio

glTranslated(0,0,-10);

//glRotated permite rotar un objeto

//------------------------------vistas de la pirámide

//--------vista de dos caras

glRotated(50,1,1,0);

//--------vista de tres caras

//glRotated(85,1,1,0);

//--------vista de la base y dos caras

//glRotated(-40,1,-5,0);

//--------vista de la base y un cara

//glRotated(200,1,0,0);

//--------vista de una cara

//glRotated(0,0,0,0);

//--------vista de la base

//glRotated(-90,100,0,0);

//--------vista de las cuatro caras

//glRotated(90,100,0,0);

//limpiamos la pantalla con un color

//glClearColor(0,0,0,0);

//glShadeModel especifica un tipo de sombreado o relleno

//en este caso es un relleno plano al tratarse de GL_FLAT

//no lo usamos para colorear como si fuese degradado

//glShadeModel(GL_FLAT);

//habilitanos GL_CULL_FACE el cual especifica si facetas delantera o

//trasera son estraídas o eliminadas

glEnable(GL_CULL_FACE);

//aquí se indica que se van a extraer las facetas traseras

glCullFace(GL_BACK);

//glFrontFace define los poligones de frente o espalda

//GL_CW especifica que los polígonos se verán de frente

glFrontFace(GL_CW);

}

void Dibuja(void)

{

       //limpiamos pantalla

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

//inicio de dibujo de un cuadrado

//-----base de la piramide--varios colores

//se usa GL_QUADS para crear un cuadrilátero

glBegin(GL_QUADS);

//vértices en 3d

glColor3f(1,0,0);//rojo

glVertex3d(-4,0,-4);//4

glColor3f(1,1,0);//amarillo

glVertex3d(-4,0,4);//3

glColor3f(0,0,1);//azul

glVertex3d(4,0,4);//2

glColor3f(0,1,0);//verde

glVertex3d(4,0,-4);//1

glEnd();

//------------------caras de la pirámide

//para las caras triangulares

//se usará GL_TRIANGLES

//--------Cara 4  amarillo con blanco

glBegin(GL_TRIANGLES);

//vértices en 3d

glColor3f(1,1,1);//blanco

glVertex3d(0,4,0);

glColor3f(1,1,0);

glVertex3d(-4,0,-4);//1

glVertex3d(4,0,-4);//4

glEnd();

//--------Cara 1 rojo con blanco

glBegin(GL_TRIANGLES);

//vértices en 3d

glColor3f(1,1,1);//blanco

glVertex3d(0,4,0);

glColor3f(1,0,0);//rojo

glVertex3d(4,0,-4);

glVertex3d(4,0,4);

glEnd();

//--------Cara 3 verde con blanco

glBegin(GL_TRIANGLES);

//vértices en 3d

glColor3f(1,1,1);//blanco

glVertex3d(0,4,0);

glColor3f(0,1,0);//verde

glVertex3d(-4,0,4);

glVertex3d(-4,0,-4);

glEnd();

//-------Cara 2 azul con blanco

glBegin(GL_TRIANGLES);

//vértices en 3d

glColor3f(1,1,1);//blanco

glVertex3d(0,4,0);

glColor3f(0,0,1);//azul

glVertex3d(4,0,4);

glVertex3d(-4,0,4);

glEnd();

//cambio del bufer oculto al activo

glutSwapBuffers();

}

Ejemplo de un apuntador en C++

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

//declaración de un apuntador       

int *aptr1;

                int a=5;

//asignamos al apuntador el valor de la variable declarada anteriormente         

aptr1=&a;

//se muestra la dirección del apuntador

                cout<<"La direccion que indica el apuntador es: "<<aptr1<< endl;

//se muestra el valor real del apuntador

                cout<<"El valor  real del apuntador es: "<<*aptr1<< endl;

                system("pause");

                return 0;

}

Ejemplo de un arreglo en C++

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

//Arreglo entero de 3 elementos inicializados todos en 0.

int arregloEntero[3] = {0}; 

                               cout << "Arreglo recien declarado: " << endl;

//se muestran los valores del arreglo

                for (int i = 0 ; i < 3 ; i++)   

                               cout << "Arreglo["<<i<<"]="<<arregloEntero[i]<< endl;

//se piden nuevos valores para cada uno de los

//elementos del arreglo

                cout << "Introduzca 3 nuevos valores " << endl;

                for (int i = 0 ; i < 3 ; i++)  

                {   

                               cout << " Introduzca nuevo valor para Arreglo["<<i<<"]" << endl; 

                cin >> arregloEntero[i];  

                }

//se muestran los nuevos valores del arreglo

cout << "Luego de los valores introducidos, el arreglo quedo asi: " << endl;

for (int i = 0 ; i < 3 ; i++)   

                cout << "Arreglo["<<i<<"]="<<arregloEntero[i] << endl;

                system("pause");

                return 0;

}

Estructuras de repetición en C++

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

//ciclo for para Imprimir

// los números del 0 al 9

int I;

for(I=0;I<10;I++)

{

cout<<""<<I;

cout<<"\n";

}

//ciclo while para mostrar los números

//del 1 la 5 seguidos del nombre Hugo

int x=1;

while(x<=5)

{

                printf("%d Hugo",x);

                x++;

                cout<<"\n";

}

system("pause");

                return 0;

}

Estructuras de decisión en C++

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

//uso de if y else para determinar

                //si un número es positivo o negativo

double N;

cout<<"Introduzca un numero diferente de cero:";

cin>>N;

//si el número es mayor que cero

//indicará que es positivo

if (N>0)

cout<<"El numero es positivo.";

//si no es así entonces es

//un número negativo

else

cout<<"El numero es negativo.";

cout<<"\n";

//uso de switch para determinar el caracter tecleado

char letra;

cout<<"Teclea la letra a o la letra b:";

cin>>letra;

//el switch evaluará la variable letra

switch(letra)

{

                //en caso de ser la a

                //indicará que tecleo la a

case 'a': cout<<"Tecleo la a";

                break;

                //en caso de ser la b

                //indicará que tecleo la b

case 'b': cout<<"Tecleo la b";

                break;

                //si teclea un caracter diferente

                //se indicará el error

                default:cout<<"Tecla incorrecta";

                break;

}

cout<<"\n";

system("pause");

                return 0;

}

Ejemplo de entradas y salidas estandar en C++

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

double N;

//cout sirve para mostrar en pantalla información

cout<<" Introduce un numero:";

//con cin leemos lo que se teclea

//y lo guardamos en una variable

cin>>N;

//se muestra en pantalla el número tecleado

cout<<" El numero insertado es: "<<N;

//la  \n es un salto de línea

cout<<"\n";

//con printf tambien podemos mostrar

//en pantalla información

printf("Gracias");

cout<<"\n";

//pausa para detener la pantalla

system("pause");

return 0;

}