C é ling. de louco

[quote=Nietzsche]Tenho um contato com Java a algum tempo…comecei na faculdade a dar C,
como essas cosias são possíveis?[/quote]

c é uma linguagem de médio nível. Não se pode comparar as duas porque são ferramentas completamente diferentes.

[quote]int main(){ //What a hell??Pra que merda main tem retorno int?? char c = 5000000; //Mais de 16 bits unsigned O.O return 5; printf("%d",5); //O retorno ta na linha de cima,codigo inalcançável!! }
[/quote]

int main(){ //para o sistema operacional saber que seu programa terminou corretamente ou terminou por algum problema unsigned char c = 5000000; //**Mais de 16 bits unsigned O.O** - char possui apenas 8 bits na linguagem c. return 5; // 0 para bem sucedido ou 1 para algum problema printf("%d",5); //O retorno ta na linha de cima,codigo inalcançável!! }

[quote=Nietzsche]
Alguem mais aew concorda comigo?Tava a um tempao sem postar,precisava compartilhar isso!!
Saudade de Java…tudo certinho,tudo no seu devido lugar…humpff :([/quote]

Se o “dar c” resume lecionar essa linguagem na faculdade seus alunos estão perdidos.

O JAVA FOI FEITO EM C…

o cara que manja mais java no mundo é louco por que programa em C ??? :?

C é antigo…ja existem tantos sistemas ai de baixo nivel que contem pogs como as que você citou…que se houvesse uma “atualização” da linguagem…daria muitas zicas nos códigos fontes…

mais tem coisa que eu admito é uma barbaridade rs…

você é professor de faculdade mesmo ?

Eu diria que eles são sortudos.

Quase todas as universidade de ponta que você for você vai ver que a linguagem base é C.

Você aprende muito programando em C.

Como o julio disse, são ferramentas completamente diferentes. Dificilmente você vai conseguir escrever uma aplicação Web em C, acho que até existe CGI para C, mas com certeza sua produtividade será terrível. Em compensação, é a ferramenta ideal quando você precisa controlar hardware, interagir com o SO ou então fazer um controle da memória utilizada.

[quote=Stacker][quote=juliocbq]
Se o “dar c” resume lecionar essa linguagem na faculdade seus alunos estão perdidos.
[/quote]

Eu diria que eles são sortudos.

Quase todas as universidade de ponta que você for você vai ver que a linguagem base é C.

Você aprende muito programando em C.[/quote]

Não critiquei a linguagem c. Critiquei a quantidade de código escrito errado lá em cima. Se você ler por inteiro o meu post vai ver que eu concordo com você.

Não tem como ficar comparando java com c porque a segunda é uma linguagem concebida para programação de sistemas. Quando se diz sistemas quer dizer sistemas operacionais mesmo. Uma categoria de desenvolvimento chamada system programming.

A linguagem c é desenhada para desenvolver compiladores, kernels, softwares para microcontroladores e não para o desenvolvimento de aplicações como é o caso da java.

[quote=Nietzsche]Tenho um contato com Java a algum tempo…comecei na faculdade a dar C,
como essas cosias são possíveis?

int main(){ //What a hell??Pra que merda main tem retorno int?? char c = 5000000; //Mais de 16 bits unsigned O.O return 5; printf("%d",5); //O retorno ta na linha de cima,codigo inalcançável!! }

Alguem mais aew concorda comigo?Tava a um tempao sem postar,precisava compartilhar isso!!
Saudade de Java…tudo certinho,tudo no seu devido lugar…humpff :([/quote]

Esquece velho, C e Java são linguagens com propósitos diferentes, mesmo assim, como dizia um amigo: “C eh esculpir na pedra, Java eh macinha para modelar…” e C não é fortemente tipada como o Java.

[]'s

[quote=Nietzsche]Tenho um contato com Java a algum tempo…comecei na faculdade a dar C,
como essas cosias são possíveis?

int main(){ //What a hell??Pra que merda main tem retorno int?? char c = 5000000; //Mais de 16 bits unsigned O.O return 5; printf("%d",5); //O retorno ta na linha de cima,codigo inalcançável!! }

Alguem mais aew concorda comigo?Tava a um tempao sem postar,precisava compartilhar isso!!
Saudade de Java…tudo certinho,tudo no seu devido lugar…humpff :([/quote]

Você está dando aulas de C? Aprenda algumas coisinhas antes de falar besteira.

a) O tipo de retorno da função main é “int” porque você fazer isto em C:

int main (int argc, char *argv[]) {
    return 1;
}

equivale a fazer isto em Java:

public static void main (String[] args) {
    System.exit (1);
}

Aliás, há vários jeitos corretos de declarar o main. Por exemplo, do jeito que eu escrevi, do jeito que você fez, ou então:

int main (int argc, char *argv[], char *envp[]) {

onde envp é um array das variáveis de ambiente do sistema (tal como System.getenv() no Java).

b) Um char tem 8 bits (não 16 bits como no Java - preste atenção!). O compilador pode aceitar o código acima - e nesse caso o comportamento, a rigor, é indefinido*, ou então gerar um warning. Isso é feito CONSCIENTEMENTE. Isso não é classificado como um erro.

  • O comportamento mais comum é a atribuição acima ser equivalente a:
char c = (char ) (5000000 & 0xFF);

mas pode ser que o compilador gere código equivalente a:

char c = (char ) ((5000000 & 0xFF000000) >> 24);

Portanto, você precisa tomar cuidado e sempre prestar atenção em todos os warnings que o compilador gera.

c) Na definição da linguagem C nada está escrito que o compilador tenha de fazer análise de fluxo e aceitar código “unreachable” (inalcançável). Ele pode gerar um warning nesse caso. Se você pensar bem, uma análise de fluxo bem-feita e na verdade mais difícil de fazer que parece, e muito código que você, em uma primeira olhada, diria que o código é executável, mas se a análise for feita, você vai ver que não é. Isso normalmente é feito por alguns compiladores (como o clang) que analisam seu programa inteiro (não apenas uma função isolada) para determinar se há “código morto”.

Aham, o JDK foi escrito em uma mistura de várias linguagens: C++, Assembly e Java.

Cuidado que C não é C++, assim como seu pai não é você. Ele “pode ter a sua cara” e metade dos seus genes, mas não é você.

o problema ai seria a quantidade de gambiarra, não a linguagem em si… e gambiarra existe em qualquer linguagem.

Aham, o JDK foi escrito em uma mistura de várias linguagens: C++, Assembly e Java.

Cuidado que C não é C++, assim como seu pai não é você. Ele “pode ter a sua cara” e metade dos seus genes, mas não é você. [/quote]

nos Docs da Sun ta escrito que o runtime foi escrito em Ansi C

http://java.sun.com/docs/overviews/java/java-overview-1.html

“The Java system itself is quite portable. The compiler is written in Java and the runtime is written in ANSI C with a clean portability boundary. The portability boundary is essentially a POSIX subset.”

não posso dizer que o jdk original não usou C “nunca vi o código original”…mais o OpenJdk nas pastas do Hotspot e Native…usam tanto C++ quanto C…talves o assembly esteja no meio do código

mais na real…

o runtime é o verdadeiro java…ele que interpreta os bytecodes java e transforma em binario…essa transformação pelo hotspot em algumas partes é compilada em C++, mas o executavel la que segura a JVM que esta dentro do runtime é em Ansi C

por exemplo, o PHP foi feito em C, e é como se os bytecodes java estivessem no mesmo nivel de um código em php, para ser interpretado pelo Runtime (php.exe e JRE.exe)

é verdade. O objetivo da linguagem c é ter pouca abstração do hardware, para que você possa fazer o que é passível de ser feito em assembly sem ter que lidar diretamente com mnemônicos.

é verdade. O objetivo da linguagem c é ter pouca abstração do hardware, para que você possa fazer o que é passível de ser feito em assembly sem ter que lidar diretamente com mnemônicos.

[/quote]

<troll> há quem diga que usar uma linguagem com pouca abstração assim hoje em dia com as opções que temos não é coisa de gente normal </troll>

hehe… brincadeira…

Aham, o JDK foi escrito em uma mistura de várias linguagens: C++, Assembly e Java.

[/quote]

OK, concordo que há alguns fontes em C no fonte do JDK (que pode ser baixado em http://www.java.net/download/openjdk/jdk7u2/promoted/b13/openjdk-7u2-fcs-src-b13-17_nov_2011.zip ) mas eles normalmente são para implementar certas coisas, como o suporte a compressão via zlib, que foram escritos por terceiros. Mas o grosso mesmo é C++, que não é C, assim como você não é seu pai (ou sua mãe), embora tenha metade dos genes dele (dela).

é verdade. O objetivo da linguagem c é ter pouca abstração do hardware, para que você possa fazer o que é passível de ser feito em assembly sem ter que lidar diretamente com mnemônicos.

[/quote]

<troll> há quem diga que usar uma linguagem com pouca abstração assim hoje em dia com as opções que temos não é coisa de gente normal </troll>

hehe… brincadeira…[/quote]

apesar de alguns falarem esse monte de bobagens, esse tipo de linguagem é essencial no desenvolvimento de hardware. Existem linguagens de sistemas mais modernas como c++ e d(Que também são linguagens de alto nível).

por exemplo, em um hd moderno hoje existem uma boa quantidade de circuitos de controle que necessitam desse tipo de software.

O runtime do Java é bem grande, e ele realmente tem muito código em C++. Por exemplo, o just-in-time compiler, que é um programa super-complexo e que é necessário para o Java transformar os bytecodes (.class) para código de máquina, é em C++.

o hotspot usa parte do projeto llvm para otimizar código de máquina.

eu nunca usei esse clang aí, mas deve ser bom.

http://llvm.org/

cara eu to muito confuso… nos Docs ta escrito que é C

…mais na pasta HotSpot da OpenJDK realmente é 95% C++

Diretório: openjdk\hotspot\src\share\vm

dentro dessa pasta esta todo o codigo que da pra ser usado entre os SOs win/linux/solaris etc…:

esse código da openjdk não é o código original da jdk não é… ?

pode ser que hoje, as vms da oracle sejam em C++…

nem sei… antes dava pra baixar os fontes, ai a oracle comprou, zicou tudo

aqui ta a definição dos bytecodes no arquivo bytecodes.cpp

[code]// initialize bytecode tables - didn’t use static array initializers
// (such as {}) so we can do additional consistency checks and init-
// code is independent of actual bytecode numbering.
//
// Note 1: NULL for the format string means the bytecode doesn’t exist
// in that form.
//
// Note 2: The result type is T_ILLEGAL for bytecodes where the top of stack
// type after execution is not only determined by the bytecode itself.

// Java bytecodes
// bytecode bytecode name format wide f. result tp stk traps
def(_nop , “nop” , “b” , NULL , T_VOID , 0, false);
def(_aconst_null , “aconst_null” , “b” , NULL , T_OBJECT , 1, false);
def(_iconst_m1 , “iconst_m1” , “b” , NULL , T_INT , 1, false);
def(_iconst_0 , “iconst_0” , “b” , NULL , T_INT , 1, false);
def(_iconst_1 , “iconst_1” , “b” , NULL , T_INT , 1, false);
def(_iconst_2 , “iconst_2” , “b” , NULL , T_INT , 1, false);
def(_iconst_3 , “iconst_3” , “b” , NULL , T_INT , 1, false);
def(_iconst_4 , “iconst_4” , “b” , NULL , T_INT , 1, false);
def(_iconst_5 , “iconst_5” , “b” , NULL , T_INT , 1, false);
def(_lconst_0 , “lconst_0” , “b” , NULL , T_LONG , 2, false);
def(_lconst_1 , “lconst_1” , “b” , NULL , T_LONG , 2, false);
def(_fconst_0 , “fconst_0” , “b” , NULL , T_FLOAT , 1, false);
def(_fconst_1 , “fconst_1” , “b” , NULL , T_FLOAT , 1, false);
def(_fconst_2 , “fconst_2” , “b” , NULL , T_FLOAT , 1, false);
def(_dconst_0 , “dconst_0” , “b” , NULL , T_DOUBLE , 2, false);
def(_dconst_1 , “dconst_1” , “b” , NULL , T_DOUBLE , 2, false);
def(_bipush , “bipush” , “bc” , NULL , T_INT , 1, false);
def(_sipush , “sipush” , “bcc” , NULL , T_INT , 1, false);
def(_ldc , “ldc” , “bk” , NULL , T_ILLEGAL, 1, true );
def(_ldc_w , “ldc_w” , “bkk” , NULL , T_ILLEGAL, 1, true );
def(_ldc2_w , “ldc2_w” , “bkk” , NULL , T_ILLEGAL, 2, true );
def(_iload , “iload” , “bi” , “wbii” , T_INT , 1, false);
def(_lload , “lload” , “bi” , “wbii” , T_LONG , 2, false);
def(_fload , “fload” , “bi” , “wbii” , T_FLOAT , 1, false);
def(_dload , “dload” , “bi” , “wbii” , T_DOUBLE , 2, false);
def(_aload , “aload” , “bi” , “wbii” , T_OBJECT , 1, false);
def(_iload_0 , “iload_0” , “b” , NULL , T_INT , 1, false);
def(_iload_1 , “iload_1” , “b” , NULL , T_INT , 1, false);
def(_iload_2 , “iload_2” , “b” , NULL , T_INT , 1, false);
def(_iload_3 , “iload_3” , “b” , NULL , T_INT , 1, false);
def(_lload_0 , “lload_0” , “b” , NULL , T_LONG , 2, false);
def(_lload_1 , “lload_1” , “b” , NULL , T_LONG , 2, false);
def(_lload_2 , “lload_2” , “b” , NULL , T_LONG , 2, false);
def(_lload_3 , “lload_3” , “b” , NULL , T_LONG , 2, false);
def(_fload_0 , “fload_0” , “b” , NULL , T_FLOAT , 1, false);
def(_fload_1 , “fload_1” , “b” , NULL , T_FLOAT , 1, false);
def(_fload_2 , “fload_2” , “b” , NULL , T_FLOAT , 1, false);
def(_fload_3 , “fload_3” , “b” , NULL , T_FLOAT , 1, false);
def(_dload_0 , “dload_0” , “b” , NULL , T_DOUBLE , 2, false);
def(_dload_1 , “dload_1” , “b” , NULL , T_DOUBLE , 2, false);
def(_dload_2 , “dload_2” , “b” , NULL , T_DOUBLE , 2, false);
def(_dload_3 , “dload_3” , “b” , NULL , T_DOUBLE , 2, false);
def(_aload_0 , “aload_0” , “b” , NULL , T_OBJECT , 1, true ); // rewriting in interpreter
def(_aload_1 , “aload_1” , “b” , NULL , T_OBJECT , 1, false);
def(_aload_2 , “aload_2” , “b” , NULL , T_OBJECT , 1, false);
def(_aload_3 , “aload_3” , “b” , NULL , T_OBJECT , 1, false);
def(_iaload , “iaload” , “b” , NULL , T_INT , -1, true );
def(_laload , “laload” , “b” , NULL , T_LONG , 0, true );
def(_faload , “faload” , “b” , NULL , T_FLOAT , -1, true );
def(_daload , “daload” , “b” , NULL , T_DOUBLE , 0, true );
def(_aaload , “aaload” , “b” , NULL , T_OBJECT , -1, true );
def(_baload , “baload” , “b” , NULL , T_INT , -1, true );
def(_caload , “caload” , “b” , NULL , T_INT , -1, true );
def(_saload , “saload” , “b” , NULL , T_INT , -1, true );
def(_istore , “istore” , “bi” , “wbii” , T_VOID , -1, false);
def(_lstore , “lstore” , “bi” , “wbii” , T_VOID , -2, false);
def(_fstore , “fstore” , “bi” , “wbii” , T_VOID , -1, false);
def(_dstore , “dstore” , “bi” , “wbii” , T_VOID , -2, false);
def(_astore , “astore” , “bi” , “wbii” , T_VOID , -1, false);
def(_istore_0 , “istore_0” , “b” , NULL , T_VOID , -1, false);
def(_istore_1 , “istore_1” , “b” , NULL , T_VOID , -1, false);
def(_istore_2 , “istore_2” , “b” , NULL , T_VOID , -1, false);
def(_istore_3 , “istore_3” , “b” , NULL , T_VOID , -1, false);
def(_lstore_0 , “lstore_0” , “b” , NULL , T_VOID , -2, false);
def(_lstore_1 , “lstore_1” , “b” , NULL , T_VOID , -2, false);
def(_lstore_2 , “lstore_2” , “b” , NULL , T_VOID , -2, false);
def(_lstore_3 , “lstore_3” , “b” , NULL , T_VOID , -2, false);
def(_fstore_0 , “fstore_0” , “b” , NULL , T_VOID , -1, false);
def(_fstore_1 , “fstore_1” , “b” , NULL , T_VOID , -1, false);
def(_fstore_2 , “fstore_2” , “b” , NULL , T_VOID , -1, false);
def(_fstore_3 , “fstore_3” , “b” , NULL , T_VOID , -1, false);
def(_dstore_0 , “dstore_0” , “b” , NULL , T_VOID , -2, false);
def(_dstore_1 , “dstore_1” , “b” , NULL , T_VOID , -2, false);
def(_dstore_2 , “dstore_2” , “b” , NULL , T_VOID , -2, false);
def(_dstore_3 , “dstore_3” , “b” , NULL , T_VOID , -2, false);
def(_astore_0 , “astore_0” , “b” , NULL , T_VOID , -1, false);
def(_astore_1 , “astore_1” , “b” , NULL , T_VOID , -1, false);
def(_astore_2 , “astore_2” , “b” , NULL , T_VOID , -1, false);
def(_astore_3 , “astore_3” , “b” , NULL , T_VOID , -1, false);
def(_iastore , “iastore” , “b” , NULL , T_VOID , -3, true );
def(_lastore , “lastore” , “b” , NULL , T_VOID , -4, true );
def(_fastore , “fastore” , “b” , NULL , T_VOID , -3, true );
def(_dastore , “dastore” , “b” , NULL , T_VOID , -4, true );
def(_aastore , “aastore” , “b” , NULL , T_VOID , -3, true );
def(_bastore , “bastore” , “b” , NULL , T_VOID , -3, true );
def(_castore , “castore” , “b” , NULL , T_VOID , -3, true );
def(_sastore , “sastore” , “b” , NULL , T_VOID , -3, true );
def(_pop , “pop” , “b” , NULL , T_VOID , -1, false);
def(_pop2 , “pop2” , “b” , NULL , T_VOID , -2, false);
def(_dup , “dup” , “b” , NULL , T_VOID , 1, false);
def(_dup_x1 , “dup_x1” , “b” , NULL , T_VOID , 1, false);
def(_dup_x2 , “dup_x2” , “b” , NULL , T_VOID , 1, false);
def(_dup2 , “dup2” , “b” , NULL , T_VOID , 2, false);
def(_dup2_x1 , “dup2_x1” , “b” , NULL , T_VOID , 2, false);
def(_dup2_x2 , “dup2_x2” , “b” , NULL , T_VOID , 2, false);
def(_swap , “swap” , “b” , NULL , T_VOID , 0, false);
def(_iadd , “iadd” , “b” , NULL , T_INT , -1, false);
def(_ladd , “ladd” , “b” , NULL , T_LONG , -2, false);
def(_fadd , “fadd” , “b” , NULL , T_FLOAT , -1, false);
def(_dadd , “dadd” , “b” , NULL , T_DOUBLE , -2, false);
def(_isub , “isub” , “b” , NULL , T_INT , -1, false);
def(_lsub , “lsub” , “b” , NULL , T_LONG , -2, false);
def(_fsub , “fsub” , “b” , NULL , T_FLOAT , -1, false);
def(_dsub , “dsub” , “b” , NULL , T_DOUBLE , -2, false);
def(_imul , “imul” , “b” , NULL , T_INT , -1, false);
def(_lmul , “lmul” , “b” , NULL , T_LONG , -2, false);
def(_fmul , “fmul” , “b” , NULL , T_FLOAT , -1, false);
def(_dmul , “dmul” , “b” , NULL , T_DOUBLE , -2, false);
def(_idiv , “idiv” , “b” , NULL , T_INT , -1, true );
def(_ldiv , “ldiv” , “b” , NULL , T_LONG , -2, true );
def(_fdiv , “fdiv” , “b” , NULL , T_FLOAT , -1, false);
def(_ddiv , “ddiv” , “b” , NULL , T_DOUBLE , -2, false);
def(_irem , “irem” , “b” , NULL , T_INT , -1, true );
def(_lrem , “lrem” , “b” , NULL , T_LONG , -2, true );
def(_frem , “frem” , “b” , NULL , T_FLOAT , -1, false);
def(_drem , “drem” , “b” , NULL , T_DOUBLE , -2, false);
def(_ineg , “ineg” , “b” , NULL , T_INT , 0, false);
def(_lneg , “lneg” , “b” , NULL , T_LONG , 0, false);
def(_fneg , “fneg” , “b” , NULL , T_FLOAT , 0, false);
def(_dneg , “dneg” , “b” , NULL , T_DOUBLE , 0, false);
def(_ishl , “ishl” , “b” , NULL , T_INT , -1, false);
def(_lshl , “lshl” , “b” , NULL , T_LONG , -1, false);
def(_ishr , “ishr” , “b” , NULL , T_INT , -1, false);
def(_lshr , “lshr” , “b” , NULL , T_LONG , -1, false);
def(_iushr , “iushr” , “b” , NULL , T_INT , -1, false);
def(_lushr , “lushr” , “b” , NULL , T_LONG , -1, false);
def(_iand , “iand” , “b” , NULL , T_INT , -1, false);
def(_land , “land” , “b” , NULL , T_LONG , -2, false);
def(_ior , “ior” , “b” , NULL , T_INT , -1, false);
def(_lor , “lor” , “b” , NULL , T_LONG , -2, false);
def(_ixor , “ixor” , “b” , NULL , T_INT , -1, false);
def(_lxor , “lxor” , “b” , NULL , T_LONG , -2, false);
def(_iinc , “iinc” , “bic” , “wbiicc”, T_VOID , 0, false);
def(_i2l , “i2l” , “b” , NULL , T_LONG , 1, false);
def(_i2f , “i2f” , “b” , NULL , T_FLOAT , 0, false);
def(_i2d , “i2d” , “b” , NULL , T_DOUBLE , 1, false);
def(_l2i , “l2i” , “b” , NULL , T_INT , -1, false);
def(_l2f , “l2f” , “b” , NULL , T_FLOAT , -1, false);
def(_l2d , “l2d” , “b” , NULL , T_DOUBLE , 0, false);
def(_f2i , “f2i” , “b” , NULL , T_INT , 0, false);
def(_f2l , “f2l” , “b” , NULL , T_LONG , 1, false);
def(_f2d , “f2d” , “b” , NULL , T_DOUBLE , 1, false);
def(_d2i , “d2i” , “b” , NULL , T_INT , -1, false);
def(_d2l , “d2l” , “b” , NULL , T_LONG , 0, false);
def(_d2f , “d2f” , “b” , NULL , T_FLOAT , -1, false);
def(_i2b , “i2b” , “b” , NULL , T_BYTE , 0, false);
def(_i2c , “i2c” , “b” , NULL , T_CHAR , 0, false);
def(_i2s , “i2s” , “b” , NULL , T_SHORT , 0, false);
def(_lcmp , “lcmp” , “b” , NULL , T_VOID , -3, false);
def(_fcmpl , “fcmpl” , “b” , NULL , T_VOID , -1, false);
def(_fcmpg , “fcmpg” , “b” , NULL , T_VOID , -1, false);
def(_dcmpl , “dcmpl” , “b” , NULL , T_VOID , -3, false);
def(_dcmpg , “dcmpg” , “b” , NULL , T_VOID , -3, false);
def(_ifeq , “ifeq” , “boo” , NULL , T_VOID , -1, false);
def(_ifne , “ifne” , “boo” , NULL , T_VOID , -1, false);
def(_iflt , “iflt” , “boo” , NULL , T_VOID , -1, false);
def(_ifge , “ifge” , “boo” , NULL , T_VOID , -1, false);
def(_ifgt , “ifgt” , “boo” , NULL , T_VOID , -1, false);
def(_ifle , “ifle” , “boo” , NULL , T_VOID , -1, false);
def(_if_icmpeq , “if_icmpeq” , “boo” , NULL , T_VOID , -2, false);
def(_if_icmpne , “if_icmpne” , “boo” , NULL , T_VOID , -2, false);
def(_if_icmplt , “if_icmplt” , “boo” , NULL , T_VOID , -2, false);
def(_if_icmpge , “if_icmpge” , “boo” , NULL , T_VOID , -2, false);
def(_if_icmpgt , “if_icmpgt” , “boo” , NULL , T_VOID , -2, false);
def(_if_icmple , “if_icmple” , “boo” , NULL , T_VOID , -2, false);
def(_if_acmpeq , “if_acmpeq” , “boo” , NULL , T_VOID , -2, false);
def(_if_acmpne , “if_acmpne” , “boo” , NULL , T_VOID , -2, false);
def(_goto , “goto” , “boo” , NULL , T_VOID , 0, false);
def(_jsr , “jsr” , “boo” , NULL , T_INT , 0, false);
def(_ret , “ret” , “bi” , “wbii” , T_VOID , 0, false);
def(_tableswitch , “tableswitch” , “” , NULL , T_VOID , -1, false); // may have backward branches
def(_lookupswitch , “lookupswitch” , “” , NULL , T_VOID , -1, false); // rewriting in interpreter
def(_ireturn , “ireturn” , “b” , NULL , T_INT , -1, true);
def(_lreturn , “lreturn” , “b” , NULL , T_LONG , -2, true);
def(_freturn , “freturn” , “b” , NULL , T_FLOAT , -1, true);
def(_dreturn , “dreturn” , “b” , NULL , T_DOUBLE , -2, true);
def(_areturn , “areturn” , “b” , NULL , T_OBJECT , -1, true);
def(_return , “return” , “b” , NULL , T_VOID , 0, true);
def(_getstatic , “getstatic” , “bJJ” , NULL , T_ILLEGAL, 1, true );
def(_putstatic , “putstatic” , “bJJ” , NULL , T_ILLEGAL, -1, true );
def(_getfield , “getfield” , “bJJ” , NULL , T_ILLEGAL, 0, true );
def(_putfield , “putfield” , “bJJ” , NULL , T_ILLEGAL, -2, true );
def(_invokevirtual , “invokevirtual” , “bJJ” , NULL , T_ILLEGAL, -1, true);
def(_invokespecial , “invokespecial” , “bJJ” , NULL , T_ILLEGAL, -1, true);
def(invokestatic , “invokestatic” , “bJJ” , NULL , T_ILLEGAL, 0, true);
def(invokeinterface , “invokeinterface” , "bJJ
", NULL , T_ILLEGAL, -1, true);
def(_invokedynamic , “invokedynamic” , “bJJJJ”, NULL , T_ILLEGAL, 0, true );
def(_new , “new” , “bkk” , NULL , T_OBJECT , 1, true );
def(_newarray , “newarray” , “bc” , NULL , T_OBJECT , 0, true );
def(_anewarray , “anewarray” , “bkk” , NULL , T_OBJECT , 0, true );
def(_arraylength , “arraylength” , “b” , NULL , T_VOID , 0, true );
def(_athrow , “athrow” , “b” , NULL , T_VOID , -1, true );
def(_checkcast , “checkcast” , “bkk” , NULL , T_OBJECT , 0, true );
def(_instanceof , “instanceof” , “bkk” , NULL , T_INT , 0, true );
def(_monitorenter , “monitorenter” , “b” , NULL , T_VOID , -1, true );
def(_monitorexit , “monitorexit” , “b” , NULL , T_VOID , -1, true );
def(_wide , “wide” , “” , NULL , T_VOID , 0, false);
def(_multianewarray , “multianewarray” , “bkkc” , NULL , T_OBJECT , 1, true );
def(_ifnull , “ifnull” , “boo” , NULL , T_VOID , -1, false);
def(_ifnonnull , “ifnonnull” , “boo” , NULL , T_VOID , -1, false);
def(_goto_w , “goto_w” , “boooo”, NULL , T_VOID , 0, false);
def(_jsr_w , “jsr_w” , “boooo”, NULL , T_INT , 0, false);
def(_breakpoint , “breakpoint” , “” , NULL , T_VOID , 0, true);

// JVM bytecodes
// bytecode bytecode name format wide f. result tp stk traps std code

def(_fast_agetfield , “fast_agetfield” , “bJJ” , NULL , T_OBJECT , 0, true , _getfield );
def(_fast_bgetfield , “fast_bgetfield” , “bJJ” , NULL , T_INT , 0, true , _getfield );
def(_fast_cgetfield , “fast_cgetfield” , “bJJ” , NULL , T_CHAR , 0, true , _getfield );
def(_fast_dgetfield , “fast_dgetfield” , “bJJ” , NULL , T_DOUBLE , 0, true , _getfield );
def(_fast_fgetfield , “fast_fgetfield” , “bJJ” , NULL , T_FLOAT , 0, true , _getfield );
def(_fast_igetfield , “fast_igetfield” , “bJJ” , NULL , T_INT , 0, true , _getfield );
def(_fast_lgetfield , “fast_lgetfield” , “bJJ” , NULL , T_LONG , 0, true , _getfield );
def(_fast_sgetfield , “fast_sgetfield” , “bJJ” , NULL , T_SHORT , 0, true , _getfield );

def(_fast_aputfield , “fast_aputfield” , “bJJ” , NULL , T_OBJECT , 0, true , _putfield );
def(_fast_bputfield , “fast_bputfield” , “bJJ” , NULL , T_INT , 0, true , _putfield );
def(_fast_cputfield , “fast_cputfield” , “bJJ” , NULL , T_CHAR , 0, true , _putfield );
def(_fast_dputfield , “fast_dputfield” , “bJJ” , NULL , T_DOUBLE , 0, true , _putfield );
def(_fast_fputfield , “fast_fputfield” , “bJJ” , NULL , T_FLOAT , 0, true , _putfield );
def(_fast_iputfield , “fast_iputfield” , “bJJ” , NULL , T_INT , 0, true , _putfield );
def(_fast_lputfield , “fast_lputfield” , “bJJ” , NULL , T_LONG , 0, true , _putfield );
def(_fast_sputfield , “fast_sputfield” , “bJJ” , NULL , T_SHORT , 0, true , _putfield );

def(_fast_aload_0 , “fast_aload_0” , “b” , NULL , T_OBJECT , 1, true , _aload_0 );
def(_fast_iaccess_0 , “fast_iaccess_0” , “b_JJ” , NULL , T_INT , 1, true , _aload_0 );
def(_fast_aaccess_0 , “fast_aaccess_0” , “b_JJ” , NULL , T_OBJECT , 1, true , _aload_0 );
def(_fast_faccess_0 , “fast_faccess_0” , “b_JJ” , NULL , T_OBJECT , 1, true , _aload_0 );

def(_fast_iload , “fast_iload” , “bi” , NULL , T_INT , 1, false, _iload);
def(_fast_iload2 , “fast_iload2” , “bi_i” , NULL , T_INT , 2, false, _iload);
def(fast_icaload , “fast_icaload” , "bi" , NULL , T_INT , 0, false, _iload);

// Faster method invocation.
def(_fast_invokevfinal , “fast_invokevfinal” , “bJJ” , NULL , T_ILLEGAL, -1, true, _invokevirtual );

def(_fast_linearswitch , “fast_linearswitch” , “” , NULL , T_VOID , -1, false, _lookupswitch );
def(_fast_binaryswitch , “fast_binaryswitch” , “” , NULL , T_VOID , -1, false, _lookupswitch );

def(_return_register_finalizer , “return_register_finalizer” , “b” , NULL , T_VOID , 0, true, _return);

def(_fast_aldc , “fast_aldc” , “bj” , NULL , T_OBJECT, 1, true, _ldc );
def(_fast_aldc_w , “fast_aldc_w” , “bJJ” , NULL , T_OBJECT, 1, true, _ldc_w );

def(_shouldnotreachhere , “_shouldnotreachhere” , “b” , NULL , T_VOID , 0, false);[/code]

isso é só a definição…

[quote=Nietzsche]Tenho um contato com Java a algum tempo…comecei na faculdade a dar C,
como essas cosias são possíveis?

int main(){ //What a hell??Pra que merda main tem retorno int?? char c = 5000000; //Mais de 16 bits unsigned O.O return 5; printf("%d",5); //O retorno ta na linha de cima,codigo inalcançável!! }

Alguem mais aew concorda comigo?Tava a um tempao sem postar,precisava compartilhar isso!!
Saudade de Java…tudo certinho,tudo no seu devido lugar…humpff :([/quote]

Se não estou enganado, o Turbo C da Borland já dava warnings sobre codigos inalcançáveis.

Confesso que eu tenho saudades do C, quando os hardwares eram novos e não existiam drivers para eles:

#include<stdio.h>
#include<dos.h>

void clr(void);
void get_c();
void cursor_p(void);
void s_page(void);

union REGS reg;

main()
{
	clr();
	get_c();
	putch(reg.h.ah);
	putch(reg.h.al);
}

void clr(void)
{
	reg.h.ah=0;
	reg.h.al=3;
	int86(0x0010,&reg,&reg);
}

void get_c()
{
	reg.h.ah=0;
	int86(0x0016,&reg,&reg);
}

void cursor_p(void)
{
	reg.h.bh=0;
	reg.h.al=3;
	int86(0x0010,&reg,&reg);
}

void s_page(void)
{
	reg.h.al=1;
	reg.h.ah=5;
	int86(0x0010,&reg,&reg);
}

A instrução int86 e o _asm eram nossa salvação.
Acho que nesse tempo a codificação era tão complicada que qualquer coisa que “funcionasse”, com gambiarra ou não era glorificada.

[quote=juliocbq][quote=Stacker][quote=juliocbq]
Se o “dar c” resume lecionar essa linguagem na faculdade seus alunos estão perdidos.
[/quote]

Eu diria que eles são sortudos.

Quase todas as universidade de ponta que você for você vai ver que a linguagem base é C.

Você aprende muito programando em C.[/quote]

Não critiquei a linguagem c. Critiquei a quantidade de código escrito errado lá em cima. Se você ler por inteiro o meu post vai ver que eu concordo com você.

Não tem como ficar comparando java com c porque a segunda é uma linguagem concebida para programação de sistemas. Quando se diz sistemas quer dizer sistemas operacionais mesmo. Uma categoria de desenvolvimento chamada system programming.

A linguagem c é desenhada para desenvolver compiladores, kernels, softwares para microcontroladores e não para o desenvolvimento de aplicações como é o caso da java.

http://en.wikipedia.org/wiki/System_programming[/quote]

Eu entendi sim :D.

E concordo com você. São de propósitos muito diferentes.