Ai é questão de ponto de vista ;-)[/quote]
Para discutir o assunto de forma séria, vc teria que seguir um caminho mais científico usando, por exemplo, as ideas de Popper sobre uma teoria só ter valor científico se ela for refutável, e o teste de uma teoria se dá no que ela proíbe, não no que ela permite. Dizer que OO em Ansi C é um gato e que ‘não é a mesma coisa’ é apenas ponto de vista, sem nenhum fundamento além do que a pessoa acha.
Abraços
[quote=Leonardo3001]dmarcosm,
olha só, como eu acho o pcalcado um entre vários aqui do GUJ que postam aqui para agregar conhecimento e não pra falar besteira, vou te mostrar o programinha em C com conceitos OO. Deu uma meia hora pra fazer.
Aqui o arquivo structs.h
#ifndef _STRUCTS_H
#define _STRUCTS_H
#include <stdlib.h>
#ifdef __cplusplus
extern "C" {
#endif
/* Atributos e métodos da Classe A */
/* Propriedades */
struct tA {
int varA;
};
/* Construtor */
void init_A(struct tA* pttA) {
pttA->varA = 0;
};
/* Getter */
int A_getVarA(struct tA* pttA) {
return pttA->varA;
};
/* Setter */
void A_setVarA(struct tA* pttA, int varA) {
pttA->varA = varA;
};
/* Destrutor */
void delete_A(struct tA** ptpttA) {
free(*ptpttA);
*ptpttA = 0;
};
/* Atributos e métodos da Classe B */
/* Propriedades */
struct tB {
struct tA super;
};
/* Construtor */
void init_B(struct tB* pttB) {
init_A(&(pttB->super));
};
/* Getters */
int B_getVarA(struct tB* pttB) {
struct tA* pttA = (struct tA*) pttB;
return pttA->varA + 1;
};
int B_getVarAAdd(struct tB* pttB, int i) {
struct tA* pttA = (struct tA*) pttB;
return pttA->varA + i;
};
/* Destrutor */
void delete_B(struct tB** ptpttB) {
free(*ptpttB);
*ptpttB = 0;
};
#ifdef __cplusplus
}
#endif
#endife aqui um main que usa a definição acima:
#include <stdio.h>
#include <stdlib.h>
#include "structs.h"
/*
*
*/
int main(int argc, char** argv) {
/* Vou iniciar um objetoA */
struct tA objectA;
init_A(&objectA);
/* Vou dar um get no varA no objetoA */
printf("objetoA.varA = %d\n", A_getVarA(&objectA));
/* Vou setar o objetoA */
A_setVarA(&objectA, 17);
printf("objetoA.varA = %d\n", A_getVarA(&objectA));
/* Vou criar um objetoB */
struct tB objectB;
init_B(&objectB);
/* Como um objetoB é um objetoA, vou chamar o setter da superclasse */
A_setVarA((struct tA*)&objectB, 43);
/* Vou chamar o getter do objetoB, lembre-se que adiciona 1 */
printf("objetoB.varA = %d\n", B_getVarA(&objectB));
/* Vou chamar o segundo getter do objetoB */
printf("objetoB.varA(12) = %d\n", B_getVarAAdd(&objectB, 12));
/* Vou atribuir o objetoB a uma referência ao objetoA */
struct tA* referenceA = &objectB;
/* vou chamar o getter do objeto A */
printf("referenceA.varA = %d\n", A_getVarA(referenceA));
return (0);
}Por favor, não se prenda a sintaxe. Repare que existe polimorfismo, herança e encapsulamento (ainda que getter e setter é um jeito porco de encapsular) como um paradigma orientado a objetos deve ter.
E aí, ainda acha que é impossível fazer isso em C?[/quote]
Caracas… acho q vocês não estão lendo o que eu escrevi. NUNCA disse que é impossível, NUNCA disse que não dá pra fazer e NUNCA disse que não se pode fazer.
A ÚNICA coisa que eu disse é que, o que as pessoas fazem para ter um resultado parecido em uma linguagem não OO é um gato, ou se preferirem, um Workaround! Ainda mais… disse que este é o meu ponto de vista. Isto é igual a discussão do ovo e da galinha!!!
Você disse que gastou 30 minutos pra fazer aquele exemplo idiota que eu gastei 2 minutos. E ainda por cima nem usei uma IDE, escrevi direto no editor aqui do fórum!!! É exatamente por isto que eu falo que é um gato. Não é nativo. Não é da linguagem.
Agora vai implementar só as entidades do projeto do qual eu participo. São 95 classes só na camada de entidade!!! Fora a camada de persistência, negócio e apresentação. Sem contar as classes utilitárias DAOs e Formatadores! Se agente gastar 1 ano para desenvolver isto em Java, vocês gastariam 15 para desenvolver em C ansi orientado a objetos, certo?
Teoria != Prática
Ps.: Pcalçado, sim! Eu lí os links que você passou.
E…
Quanto aos links… bem… acho que é só você dar uma pausa para reler aquilo que você já leu!
Ele implementou… 
Er… acho que quem precisa reler o que escreveu é você mesmo:
[quote=dmarcosm]OO é um paradigma. Isto todo mundo sabe! Mas criar implementações de código utilizando este paradigma é muito complicado e a linguagem de programação que está sendo utilizada deve prover estes recursos.
Falar que dá pra programar OO em C ansi, para mim, é uma bobagem sem tamanho. Alguns de vocês vão ficar chateados e vão colocar “kilos” de links para sites e livros que dizem o contrário. Mas… alguém é capaz de implementar um código simples como este utilizando C ou Pascal ou qualquer outra linguagem procedural:
Para programar OO nós devemos seguir TUDO o que manda as teorias de OO. Mas no “mundo real” isto é quase impossível. Agente sempre peca em alguma coisa. Portanto não confunda uma linguagem que dê suporte a OO (como o Java e o C++) com um código escrito seguindo as recomendações de OO.[/quote]
Aliás, se para ter um programa OO você precisa utilizar todos os conceitos que estão sob o guarda-chuva OO você não pode dizer que um programa Java o é porque ele têm não-objetos como tipos primitivos.
É engraçado ler isso sem (1) nenhum argumento que o justifique (2)você ter sequer explicado o que seria ‘ser OO’ para você.
Se existe uma ferramenta OO por que ele usaria uma não OO? Qual seu ponto?
'Acho" parece ser um bom sumário para os seus tópicos. Novamente recomendo um pouco de leitura para entender as coisas antes de comentar.
Logo…?
Na verdade faz um bom tempo que a linguagem se chama Delhpi Language mas não entendi seu ponto.
Acho que talvez você não tenha entendido o ponto fundamental:
Você disse que é besteira, nós dissemos que não e mostramos porquê. Simples assim.
Ah, e se não dá para programar OO em C não dá pra programar em AOP com Java. Simples assim.