#135 Evidentemente el software que utilice las extensiones de GNU solo se puede enlanzar contra glibc. No es el caso de por ejemplo busybox, xfce.
Como ejemplo esta Alpine Linux.

La incompatibilidad de la que usted habla solo ocurre si se utilizan las extensiones de GNU.
Ejemplo sencillo.

====== hola.c =====
#include <stdio.h>

int main(void)
{
printf("Hola Mundo");
return 0;
}
=================
$ musl-gcc -o hola_musl hola.c
$ ./hola_musl
Hola Mundo
$ objdump -T hola_musl

hola_musl: formato del fichero elf64-x86-64

DYNAMIC SYMBOL TABLE:
0000000000000000 DF UND 0000000000000000 puts
0000000000000000 DF UND 0000000000000000 __libc_start_main
0000000000601030 g D .data 0000000000000000 _edata
0000000000601038 g D .bss …   » ver todo el comentario

#2 Por Dennis Ritchie, que en paz se recompile. A mí se me declaran con ese chorizo de código y huyo despavorido. Ni punto de comparación con la elegancia de:

#include <stdio.h>

int main( int argc, char *argv[] ) {
printf( "%sn", "Vaya ojazos tienes cordera" );

return 0;
}

#11 prueba mejor así, que la noticia es de C++17 no de C
#include <iostream>
int main()
{
std::cout << "he llegado, versión 17";
return 0;
}

#include <stdio.h>
void main(){
printf("he llegado, versión 17");
}

#include

int main(int argc, char *argv[]) {
printf("Totalmente absurdo");
return 0;
}

#5 #include "siesta.h"

#72 La logica nos dice que puede que alguna linea de codigo compartiran, aunque sea un #include. Pero de ahi a que tengan los mismos errores...

NO entiendo el chiste. Aunque existen diferentes clases de C++, el aprendizaje es sumamente sencillo no requiere más de 2 semanas.


-----

EN C++
// Spain in C++ (pre-ISO)

#include <iostream.h>

main()
{
cout << "Espero que el PP-PSOE no gobierne más en España" << endl;
return 0;
}

En Java Mobile sería algo así:

// PPPSOE on a mobile Java device

package Spain;

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class PPPSOE extends MIDlet {

public PPPSOE()
{
Form form = new Form("Espero no gobierne más el PPPSOE en España");
form.append("Espero no gobierne más el PPPSOE en España");
Display.getDisplay(this).setCurrent(form);
}

protected void pauseApp() { }
protected void startApp() throws
javax.microedition.midlet.MIDletStateChangeException { }
protected void destroyApp(boolean parm1) throws
javax.microedition.midlet.MIDletStateChangeException { }
}

#include <Math>
int iFila = Math.Ramdom(2);
printf("%dn", iiFila);

Y te habrías ganao 47000 $

#40: Yo en la universidad hice uno del método Martingala de los casinos (apostar siempre al rojo y doblar la apuesta si se pierde). No recuerdo bien cómo funciona, pero bueno aquí lo dejo (licencia de dominio público), el autor de la página web está invitado a cogerlo si le interesa:

#include<stdio.h>
#include<math.h>
#include <stdlib.h>
#include <time.h>

main(){
int i, n, aleatorio, P, U;
char cadena[31];
int contador, contadortotal;
long int topeganado, topeperdido, topejugando, dinero, jugando;
contadortotal=0;
dinero=0;
topeperdido=0;
topeganado=0;
jugando=1;
topejugando=1;
printf("Numero de tiradas: ");
scanf("%s",cadena);
contador=atoi(cadena);
while(contador){
srand((int)contadortotal*3);
aleatorio = (int…   » ver todo el comentario

#33
/* CUÑAOLOCO.C */
#DEFINE EXABRUPTO_MAXLENGTH 500
#INCLUDE <STDIO.H>

INT VENAENFRENTEQUETEEXPLOTA = 1;

CHAR * ANDARGRITANDO (CHAR * PALABRANORMAL)
{
......CHAR GRITO[EXABRUPTO_MAXLENGTH]
......INT I = 0;
......WHILE(PALABRANORMAL[I] != '')
......{
...........GRITO[I] = PALABRANORMAL[I] - 0x20;
...........I++;
......}
......RETURN GRITO;
}

INT MAIN (VOID)
{
....CHAR EXABRUPTO[EXABRUPTO_MAXLENGTH]
....WHILE (VENAENFRENTEQUETEEXPLOTA)
....{
........FFLUSH(STDIN);
........SCANF("%S", EXABRUPTO);
........PRINTF("%SN", ANDARGRITANDO(EXABRUPTO));
....}
....RETURN 0;
}


$> gcc CUÑAOLOCO.c EXPULSABILIS.OUT
$> chmod u+x EXPULSABILIS.OUT
$> ./EXPULSABILIS.OUT
$>
en españa estamos en nivel de alerta 4 antiterrorista.
nivel 5 es el ejercito en las calles.
esto no es el gta5, es la vida real. y es en paris y ahora.


Profit.

#151 en.wikipedia.org/wiki/GLib

Si tu me pone Boost, pues bueno, yo no tendré problemas en ponerte una capa más idónea para usar C en el siglo XXI, y que no lastre tanto.
surf.suckless.org/
Este el navegador que te dije. Pude meter WebGL en una línea, y no, no fué ni con #DEFINE WEBGL 1 ni con #include's

No lo proveían por defecto, no te digo más. Y tampoco daban instrucciones.

#16 Y el #include <stdio.h> ?
Sin int ni return para el SO ?!?

Suspenso !! Con un 4,99

Los tres primeros son el mismo lenguaje pero con distintas palabras reservadas.


Así yo invento también en TurboRajoy++
:
#include <stdio.h>


#define BUENA int
#define GESTION main() {
#define MIRE printf
#define USTE (
#define LOS );
#define CHUCHESH MIRE USTE"n"); system("PAUSE");
#define VIVA ; return 0;
#define ESPANA }


BUENA GESTION

MIRE USTE "ESPAÑA VA BIEN"
LOS CHUCHESH

VIVA ESPANA

Bah, que tonterías, si tengo RAM es para que se use no para que se quede ahí sin hacer nada.

Yo para no tener el problema que tienen #34 o #11 uso el siguiente programa:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

char* miscosas;
int main(){
while(miscosas=malloc(1000*1000*100))
printf("Ñam\n");
while(1){
sleep(60);
sprintf(miscosas, "Jueeego, con mi melocotoneeeeero");
}
}

Es un programa pequeñito y funciona automágicamente sin tener que configurar nada. Así me aseguro de que no desperdicie RAM mi ordenador.
Ah, y por supuesto, aprovecha su nuevo meloco... digo... la RAM que usa.

El tío hace un #include "stdio.h"

Obtenido de: www.openwall.com/lists/oss-security/2015/01/27/9

<code>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define CANARY "in_the_coal_mine"

struct {
char buffer[1024];
char canary[sizeof(CANARY)];
} temp = { "buffer", CANARY };

int main(void) {
struct hostent resbuf;
struct hostent *result;
int herrno;
int retval;

/*** strlen (name) = size_needed - sizeof (*host_addr) - sizeof (*h_addr_ptrs) - 1; */
size_t len = sizeof(temp.buffer) - 16*sizeof(unsigned char) - 2*sizeof(char *) - 1;
char name[sizeof(temp.buffer)];
memset(name, '0', len);
name[len] = '';

retval = gethostbyname_r(name, &resbuf, temp.buffer, sizeof(temp.buffer), &result, &herrno);

if (strcmp(temp.canary, CANARY) != 0) {
puts("vulnerable");
exit(EXIT_SUCCESS);
}
if (retval == ERANGE) {
puts("not vulnerable");
exit(EXIT_SUCCESS);
}
puts("should not happen");
exit(EXIT_FAILURE);
}
EOF
</code>

#include <stdio.h>
#include <iostream>

int main {
int x = 0;
while(x < 10) {
printf("x¡i60.tinypic.com/miyx3p.jpgn");
}
return 0;
}

El del Windows:

#include <windows.h>
#include <system_errors.h>
#include <stdlib.h>

char make_prog_look_big[1600000];

main()
{
if (detect_cache())
disable_cache();

if (fast_cpu())
set_wait_states(lots);

set_mouse(speed, very_slow);
set_mouse(action, jumpy);
set_mouse(reaction, sometimes);

printf("Welcome to Windoze 3.999 (we might get it right
or just call it Chicargo)n");

if (system_ok())
crash(to_dos_prompt);
else
system_memory = open("a:swp0001.swp", O_CREATE);

while(1) {
sleep(5);
get_user_input();
sleep(5);
act_on_user_input();
sleep(5);
if (rand() < 0.9)
crash(complete_system);
}
return(unrecoverable_system);
}

Siempre he disfrutado de estructuras o diseños informáticos realmente soberbios. De algoritmos sublimes o frameworks que llevan la abstracción a su máximo extremo.

El problema es que lleva demasiado tiempo y preparación disfrutar de esas genialidades. Además de que es complicado encontrar lo realmente bueno dentro de millones de lineas de código. Muchas veces no es accesible por motivos de copyright.

En mi modesta opinión, la programación es una artesanía mental que tiene momentos de puro arte, pero sólo al alcance de unos pocos.

github.com/id-Software/DOOM

static const char
rcsid[] = "$Id: i_main.c,v 1.4 1997/02/03 22:45:10 b1 Exp $";



#include "doomdef.h"

#include "m_argv.h"
#include "d_main.h"

int
main
( intargc,
char**argv )
{
myargc = argc;
myargv = argv;

D_DoomMain ();

return 0;
}

Adoro un código con estilo...