FAQ 1) Onde acho um compilador?
Alguns compiladores C/C++ para distribuição livre:
[DOS]
DJGPP:
http://www.delorie.com/djgpp/
Turbo C 2.01:
Turbo C++ 1.0:
http://community.borland.com/museum
CC386:
http://www.members.tripod.com/~ladsoft/cc386.htm
[WIN32]
Borland C++ 5.5:
http://www.borland.com/bcppbuilder/freecompiler/
LCC-Win32:
http://www.cs.virginia.edu/~lcc-win32/
Cygwin:
http://sourceware.cygnus.com/cygwin/
Mingw32:
http://www.mingw.org/
Bloodshed Dev-C++:
http://www.bloodshed.ru
http://www.simtel.net/pub/simtelnet/win95/prog/dvcpp395.zip
[VARIAS PLATAFORMAS]
GCC:
http://gcc.gnu.org/
FAQ 2) Qual a diferença entre C, C++, C++Builder, Visual C++?
C é uma linguagem de programação de nível médio, utilizada em
sistemas operacionais, jogos, aplicativos gráficos, e diversos
outros tipos de aplicações que exigem alta performance.
C++ é linguagem de programação orientada a objeto, baseada na
linguagem C, e que adiciona herança, polimorfismo, dentre outros
recursos.
C++Builder é uma ferramenta da Borland para desenvolvimento visual
na plataforma Win32, utilizando-se a linguagem C++. Possui uma
interface semelhante ao Delphi, e pode utilizar componentes do
mesmo, além de compilar código ObjectPascal.
Visual C++ é a ferramenta da Microsoft para desenvolvimento na
plataforma Win32 utilizando-se a linguagem C++. O Visual C++ é
bastante poderoso, porém, não é tão simples de se utilizar.
FAQ 3) Onde arrumo um bom tutorial ou livro?
Tutoriais em Português:
[C] http://www.fej.udesc.br/dcc/icc/icc-apc.htm
[C] http://ead1.eee.ufmg.br/cursos/C/
Tutoriais em Inglês:
[C] http://book.ygm.itu.edu.tr/Book/Corona/CTut/index.htm
[C++] http://book.ygm.itu.edu.tr/Book/Corona/C++Tut/default.htm
Livros em Inglês:
Teach Yourself C++ in 21 Days:
http://book.ygm.itu.edu.tr/Book/CPP/index.htm
Thinking in C++:
http://www.bruceeckel.com/DownloadSites/
Diversos
http://www.canalcplus.cjb.net/
http://www.programmersheaven.com
http://www.informit.com
http://www.programadores.com.br
FAQ 4) Como converto um número p/ string e vice-versa?
int atoi(const char *s); /* String para int */
long double atol(const char *(s)); /* String para double long */
double atof(const char *s); /* String para float */
char *ecvt(double value, int ndig, int *dec, int *sign);
char *fcvt(double value, int ndig, int *dec, int *sign); /* float para String */
double strtod(const char *s, char **endptr); /* String para double float */
long strtol(const char *s, char **endptr, int radix); /* String para long */
unsigned long strtoul(const char *s, char **endptr, int radix); /* String para unsigned long */
int sprintf(str, "%d", numero); /* inteiro p/ string */
int sprintf(str, "%f", numero); /* float p/ string */
int sprintf(str, "%lf", numero); /* double p/ string */
int sscanf(str, "%d", &numero); /* string p/ inteiro */
int sscanf(str, "%f", &numero); /* string p/ float */
int sscanf(str, "%lf", &numero); /* string p/ double */
se o seu compilador não possui uma das funções acima, então utilize uma das outras formas.
FAQ 5) Como faço a alocação de uma matriz dinamicamente?
Em C puro:
1) Crie um ponteiro p/ o tipo de dado que você precisa,
vamos usar como exemploo tipo int
int *pMatriz;
2) Para calcular o números de bytes, multiplique o tamanho
de cada item (sizeof), pelo número de elementos
sizeof(int) * NumeroDeElementos
2) Utilize a função malloc, você pode usar também outras
funções, como calloc e realloc
void *malloc(size_t tamanho);
void *calloc(size_t elementos, size_t tamanho);
3) Atribua o que você alocou ao ponteiro, fazendo cast,
quando necessário, p/ o tipo
pMatriz = (int *)malloc(sizeof(int) * 10);
ou então
pMatriz = (int *)calloc(sizeof(int), 10);
4) Acesse a matriz normalmente, utilizando índice, ou aritmética
de ponteiro
pMatriz[n] = 0;
ou então
*(pMatriz + n) = 0;
5) Após ter utilizado a matriz e não mais precisar dela, libere-a
utilizando a função free
free(pMatriz);
6) Uma boa recomendação é atribuir um NULL ao ponteiro, p/ não se
confundir mais tarde e tentar utilizar o ponteiro mesmo após
liberado
pMatriz = NULL;
Em C++:
1) Crie um ponteiro p/ o tipo de dado que você precisa,
vamos usar como exemplo o tipo int
int *pMatriz;
2) Utilize o operador new p/ alocar e atribuir ao ponteiro
pMatriz = new int[10];
3) Acesse a matriz normalmente, utilizando índice, ou aritmética
de ponteiro
pMatriz[n] = 0;
ou então
*(pMatriz + n) = 0;
4) Após ter utilizado a matriz e não mais precisar dela, libere-a
utilizando o operador delete[]
delete [] pMatriz;
5) Uma boa recomendação é atribuir um NULL ao ponteiro, p/ não se
confundir mais tarde e tentar utilizar o ponteiro mesmo após
liberado
pMatriz = NULL;
6) A STL do C++ possui templates p/ tipos mais complexos de matrizes
e estruturas, por exemplo list, map, vector, etc
FAQ 6) Como leio uma strings com espaços em C/C++?
[C]
char str[256];
gets(str);
[C++]
char str[256];
cout.getline(str, sizeof(str));
FAQ 7) Como trabalho com listas encadeadas?
FAQ 8) Como faço comunicação serial?
FAQ 9) Como leio e escrevo na paralela?
FAQ 10) Como leio um arquivo de imagem (BMP, GIF, PCX, TIFF,
JPEG, etc)?
http://www.wotsit.org/
ftp://x2ftp.oulu.fi/pub/msdos/programming/formats/00index.html
Para Unix existem prontas bibliotecas (libtiff, libjpeg, libpng)
p/ alguns formatos de imagens, algumas delas foram portadas p/
Windows.
FAQ 11) Onde é que está o getch em Linux?
A getch e outras funções de entrada/saída p/ console são
implementadas na biblioteca ncurses
FAQ 12) Como uso o mouse no DOS e Linux?
[DOS]
Através da interrupção 33h do DOS, você pode iniciar, finalizar,
mostrar, esconder, ler e alterar a posição, ler botões pressionados,
definir a janela ativa, etc, etc, etc...
Para uma referência com a principais funções, olhe
http://casa.dos.programadores.com.br/
[Linux]
No Linux, você tem acesso ao mouse através do pseudo-dispositivo
/dev/gpmdata, exemplo de utilização podem ser vistos no diretório
do código fonte do próprio GPM
FAQ 13) Quais são os compiladores grátis ou baratos para C que existem (ambiente MS-DOS/Win32)?
Atualmente há uma boa quantidade de compiladores grátis ou
shareware com preços bem módicos à disposição:
Um compilador popular, grátis, livre e de alta qualidade é o GNU C
da Free Software Foudation (FSF) . O port para MS-DOS é o djgpp
disponível em http://www.delorie.com e em mirrors Simtel. Na
versão atual, ele gera programas para rodar no DOS no modo
protegido 32 bits (DPMI) e vem no conjunto dos seus utilitários
com um servidor DPMI grátis também. É ativamente suportado, tendo
várias bibliotecas disponíveis para ele (gráficas, jogos, etc.), a
biblioteca C que o acompanha esforça-se na facilidade de conversão
de programas seja do mundo Unix como programas DOS (especialmente
da Borland), embora existam algumas nuances que necessitam de
conversão (extensivamente discutidos no próprio FAQ desse
compilador). Para o mundo windows há dois ports atualmente
mantidos, o MingW (http://www.mingw.org) e o Cygwin
(http://sources.redhat.com/cygwin/download.html). Qual a diferença
entre eles? Basicamente a filosofia quanto ao uso de bibliotecas
compartilhadas no ambiente Win32. O Cygwin necessita de uma DLL
que cria um ambiente de emulação do Unix, enquanto o projeto do
MinG utiiliza a biblioteca MSVCRT da Microsoft (que já existe no
Windows). Diz-se ser mais fácil portar programas unix com a
primeira opção, enquanto o uso da segunda tem sido considerado
mais simples. Para as versões para Windows, há um ambiente
integrado disponível o Dev-C++, que 'nativamente' já vem com uma
versão do MingW, mas pode ser configurado para trabalhar com o
Cygwin. Portanto se você quiser poupar tempo e trabalho, uma
primeira opção seria dar uma olhada no Dev-C++ que vem com o IDE e
compilador (para os interessados, há também links para um
depurador ["debugger"] alternativo ao da FSF).
Um compilador criado pelos seus autores para descrever o projeto
de um compilador C, o lcc
(http://www.cs.princeton.edu/software/lcc), ganhou uma versão para
Win32 que tem se mostrado muito interessante, port de Jacob Navia
lcc-win32 (http://www.cs.virginia.edu/~lcc-win32). Esse pacote vem
com um IDE, editor de recursos e copiosa documentação. Este
port do compilador gera exclusivamente executáveis Win32. O lcc
original, embora possa ser de grande interesse para estudantes ou
interessados em construção de compiladores não é por si só muito
útil dado que ele necessita do Visual C/C++ da Microsoft (e do
montador MASM) para ser construído e gerar código! Uma versão
alternativa vem preparada para gerar código para o montador NASM
(Netwide Assembler), o que pode torná-lo um pouco mais
"autônomo". Ainda assim, este pacote é só o compilador e carece de
uma biblioteca padrão, tornando-o assim pouco apropriado para uso
no dia-a-dia.
Uma outra alternativa de um compilador grátis e livre, é o CCDL
(CC386) (disponível em http://members.tripod.com/~ladsoft), por
David Lindauer et al. Esse compilador gera código executável DOS
32 bits no modo protegido. No pacote vêm dois servidores
DPMI. Este compilador é capaz de usar diversos montadores em
alternativa ao NASM que já vem no seu pacote de
executáveis. Embora um produto completo, ele dispõe somente da
biblioteca padrão, não havendo 'suporte' para ele na forma de
bibliotecas gráficas, jogos, etc., por exemplo.
A Borland (Inprise) resolveu liberar para download a versão 5.5 do
seu compilador de linha de comando (não o ambiente integrado) para
Win32 (http://www.borland.com/bcppbuilder/freecompiler/), embora
grátis, para acessar o ponto de download é necessário preencher
uma ficha de "registro". Recentemente essa empresa liberou também
para download o seu depurador de linha de comando mais um dois
'service packs' e acesso a arquivos de Help (formato windows) que
documentam melhor a biblioteca e as ferramentas que vêm nesses
pacotes. Este compilador e suas ferramentas associadas geram
código Win32 exclusivamente. Devido derivar de um produto
comercial de bastante sucesso, é ativamente suportado seja no que
tange a existência de bibliotecas de terceiros bem como grupos e
listas de discussão. Na própria documentação do programa citam-se
numerosos sites de recursos auxiliares para os usuários desse
compilador.
Um compilador e ferramentas associadas grátis para gerar pequenos
executáveis DOS no modo real (modelos de memória 'tiny' ou 'small'
apenas) é o Micro C de Dave Dunfield
(http://www.dunfield.com). Embora não implemente um conjunto
completo da linguagem C, em particular lhe falta suporte a números
em ponto flutuante (float, double), inteiros longos (long), enums,
typedef e bitfields. O próprio autor é taxativo na sua
documentação que o seu compilador não é completamente compatível
com a Norma ANSI. Esse compilador requer um montador externo,
porém o pacote vem com um freeware (Arrowasm) e um linker de
domínio público (levemente modificado pelo autor do Micro C
segundo a documentação). Embora não se possa afirmar que tenha
copioso suporte, no site do próprio autor há algumas bibliotecas a
mais para DOS (swap para disco, EMS, etc.). É dotado de um IDE e
vem com um utilitário make também. O propósito do autor a
deixar essa versão do seu compilador grátis é servir de
demonstração para os produtos dele no ramo de desenvolvimento de
aplicações embutidas ("embedded systems"), os quais têm a mesma
interface e ele os vende (no seu próprio site).
Outro compilador grátis para PCs produzido por uma empresa cujo
foco é o mercado de sistemas embutidos é o Pacific C da HI-TECH
Software (http://www.htsoft.com/products/pacific.html). Os seus
autores afirmam ter seu compilador compatibilidade com o padrão
ANSI, e em adição aos binários fornecem um manual em formato
PDF. Os executáveis gerados são para DOS modo real (modelos de
memória 'small' e 'large') e permite escolher duas pastilhas como
alvo a 8086 e 80286. O compilador e suas ferramentas associadas
requerem um 286 ou superior e pelo menos 1MB de memória XMS para
rodar. Vem com um IDE em adição às ferramentas de linha de
comando. O único suporte disponível é contato com pares via um
forum disponibilizado na página da HI-TECH. Não há bibliotecas ou
outros softwares dando suporte a programação gráfica, etc. De
forma similar ao Micro C, esta versão serve aos seus autores como
propaganda para sua linha de produtos, cuja funcionalidade,
segundo eles, é similar à versão PC.
FAQ 14) Como pego a data e a hora do sistema?
Em algumas plataformas específicas existem outra funções, porém,
você pode utilizar a funções time e localtime, ambas pertencente
a biblioteca padrão, da seguinte forma:
#include
time_t ltime = time(NULL);
struct tm *today = localtime(<ime);
Os campos da estrutura tm são:
tm_sec
Segundos (0 - 59)
tm_min
Minutos (0 - 59)
tm_hour
Horas (0 - 23)
tm_mday
Dia do mês (1 - 31)
tm_mon
Mês (0 - 11; Janeiro = 0)
tm_year
Ano (ano corrente menos 1900)
tm_wday
Dia da semana (0 - 6; Domingo = 0)
tm_yday
Dia do ano (0 - 365; 1o de Janeiro = 0)
tm_isdst
Contem um valor positivo se horário de verão estiver vigorando;
Zero caso não esteja;
Um valor negativo significa que o estado do horário de verão é
desconhecido.
A biblioteca "run-time" do C assume as regras dos EUA para a
implementação do cálculo do horário de verão (Daylight Saving
Time - DST).