Wicker Man

Não só variáveis como também funções e objetos.

Opa! Quando você abre um arquivo você pode especificar o modo de abertura desse arquivo. Se você abre um arquivo para saída (usando um objeto "ofstream") o modo de abertura padrão é "ios::out", que apaga o conteúdo pré-existente no arquivo e grava os novos dados. Sendo assim, faça: ofstream fecha; fecha.open( "clientes.txt", ios::app ); O modo de abertura "ios::app" informa que a saída será gravada no final do arquivo. Até mais!

Observe o caso abaixo: #include <cstdlib> #include <iostream> using namespace std; int n = 15; namespace exemplo { int n = 10; } int main() { cout << "n global: " << n << endl; cout << "n do ambiente exemplo: " << exemplo::n << endl; system("PAUSE"); return 0; } Nesse caso temos uma variável global "n" e outra com o mesmo nome definida em um ambiente de nomes. Quando você quiser usar a "n" do escopo global, terá que referenciá-la diretamente; e quando quiser usar a "n" do namespace, é só usar o operador de definição de escopo ( :: ) precedido pelo nome do namespace e sucedido pelo componente deste namespace a ser utilizado. Sendo assm, os conflitos de escopo relacionados à variável "n" são solucionados com o uso de ambientes de nomes. Deu pra sacar?

Opa! Isso é necessário para que você possa usar o ambiente de nomes (namespace) "std", onde "cout" está definido. Os ambientes de nomes são usados para evitar confiltos de escopo, ou seja, quando o escopo de uma variável "penetra" no escopo de outra variável com o mesmo nome da primeira. Espero ter ajudado. Até mais.

Opa! Olha como você pode fazer sua função set: void setData( int m, int d ) { if ( m > 0 && m <= 12 ) // certifica que os meses serão entre 1 e 12 mes = m; else mes = 1; // atribui o valor default 1 se os dados fornecidos forem inválidos if ( d > 0 && d <= 31 ) // certifica que os dias serão entre 1 e 31 dia = d; else dia = 1; // atribui o valor default 1 se os dados fornecidos forem inválidos } Agora a função get: int getDia() { return dia; } int getMes() { return mes; } Sacou? Até mais!

Opa! Você pode começar aprendendo a criar uma interface gráfica com a API Win32: http://members.fortunecity.com/harrycik/files/Forgers.htm Até mais!

Opa! A alocação dinâmica de memória é uma importante aplicação. Outra muito importante é a passagem de parâmetros para funções por referência. Considere, por exemplo, que você tem uma função que recebe um parâmetro inteiro: #include <iostream> using namespace std; void f( int x ) { x = 5; } int main() { int p = 2; f( p ); cout << p << endl; return 0; } Isso imprimirá o número 2 na tela, ou seja, a função "f()" não afetou em nada o valor de p. Isso acontece porque o que foi passado para a função foi uma cópia do valor de p (usou-se a passagem de parâmetros por valor). Mas, se mudássemos a função para, ao invés de receber um inteiro, receber um ponteiro para um inteiro, ela recebria, na verdade, o endereço na memória da variável passada, podendo, assim, modificá-la: #include <iostream> using namespace std; void f( int *x ) { *x = 5; } int main() { int p = 2; f( &p ); cout << p << endl; return 0; } Nesse código, foi passado o endereço de p (usando o operador "&"), e a função "f()" pode modificar o valor de p. A principal vantagem desse tipo de passagem é que, quando se passa objetos muito grandes, tais como estruturas ou classes, se passarmos através da passagem por valor, a cópia de um valor muito grande teria que ser realizada. Desta forma, é muito melhor passar esses dados por referência. E se não quiser que os dados passados sejam modificados, passe-os como constantes: void f( const int *x ) { *x = 5; } Assim conseguimos mesclar a eficiência da chamada por referência com a segurança da passagem por valor. Em listas encadeadas, por exemplo, você declara um ponteiro para o próximo nó da lista. Se não se usasse ponteiros nesse caso, teríamos que sobrecarregar o operador "=", e teríamos uma queda no desempenho quando fôssemos manipular a lista. Deu pra ter uma idéia das aplicações dos ponteiros, né? Até mais!

Opa! Vou começar pelas antigas: R: Declare a variável "x" como double (substituindo o long float) e, ao referenciá-lo no printf ou no scanf, use %lf; o %f é usado somente para float. R: Não. Você pode definir uma constante dentro de uma função, mas ela só poderá ser acessada dentro da função na qual você a declarou. Declarando uma constante fora de qualquer função, torna ela acessível a todas as funções do programa. R: Se trata de diretivas de compilação. Leia isso aqui. R: Recomendo o Dev-C++. http://www.bloodshed.net/devcpp.html. Agora as duas últimas: R: O %ld é usado para referenciar variáveis do tipo long int, e o %d para variáveis do tipo int. R: Nesse caso, deve-se usar o "&" porque assim você passa o endereço da variável para a função, e não apenas uma cópia do valor da variável. Procure algo sobre passagens por valor e passagens por referência para entender melhor. Ok, acho que acabou. Até mais!

Opa! Bom, consideremos a seguinte estrutura: ... struct exemplo { char str[ 20 ]; int num; double real; char let; }; ... Agora digamos que queremos declarar um objeto dessa struct com todos os membros "zerados" (se entendi direito o que você quis dizer com isso); então, fazemos: ... struct exemplo Ex = { "", 0, 0.0, ' ' }; ... Assim você "zera" os membros, um a um, na ordem em que foram declarados. Você pode fazer isso no decorrer do programa também: ... Ex = { "", 0, 0.0, ' ' }; ... Até mais!

Opa! A função que converte uma string em um float é "atof()", e não "ataf()". Bem engenhoso o seu método. Massa mesmo! Até mais!

Opa! Depende da biblioteca que você vai usar. A mais popular é a GLUT. Ainda assim, é melhor ir aprendendo aos poucos. Viste os links abaixo: http://www.inf.unisinos.br/~marcelow/ensin...cg/tutGlut.html www.inf.pucrs.br/~manssour/OpenGL/PrimeiroPrograma.html Até mais!

Opa! Você deve incluir biblioteca "fstream". Agora você deve declarar um objeto do tipo "ifstream", da seguinte forma: ifstream iFile( "arquivo.txt" ); Agora basta usar o operador ">>" para armazenar os valores do arquivo numa variável. Por exemplo, digamos que temos um arquivo no qual está armazenado dados sobre pessoas (por exemplo, nome e idade). Vejamos: ... ifstream iFile( "arquivo.txt" ); char nome[ 25 ]; int idade; while ( iFile && !iFile.eof() ) { iFile >> nome >> idade; cout << "Nome: " << nome << "\tIdade: " << idade << endl; } ... Mas o arquivo deve existir antes de tentar acessá-lo assim. O arquivo pode ser crido quando você for abri-lo para colocar dados nele. Para isso, usa-se um objeto "ofstream" de forma similar à situação anterior. ofstream oFile( "arquivo.txt" ); E agora se usa o operador "<<" para colocar os dados no arquivo: ... ofstream iFile( "arquivo1.txt" ); char nome[ 25 ]; int idade; while ( cin >> nome >> idade ) iFile << nome << " " << idade << endl; ... OBS.: esse loop só parará quando se digitar "ctrl+z" (pelo menos no windows). Quando não for mais usar o arquivo no seu programa, use o método "close()" para fechá-lo. E é importante notar que esses são arquivos de acesso seqüencial, e não aleatório. Se qualquer coisa que não ficou clara, poste de novo. Até mais!

Opa! O Graymalkin está certo, o problema é que você está declarando a variável local "texto" como um "char" simples, e não como uma string. Você esqueceu do operador de derreferência "*". Até mais!

Opa! Olha, testei aqui com o Dev-C++ 4.9.9.2 e também não funcionou. Se também está usando esta versão, tente baixar outra (que não seja beta). Isso porque testei exatamente este código aí no compilador da Borland e funcionou. Até mais!

Entendo. Então considerando que o ponto (xb, yb) será sempre o segundo ponto de interseção da reta "r" com a circunferência dada (isto é, ela sempre interceptará (xa, ya) primeiro), vamos supor que o carro pare dentro da circunferência (ou seja, (x1, y1) dentro): d_ab = sqrt( ( xb - xa )² + ( yb - ya )² ); d_1b = sqrt( ( xb - x1 )² + ( yb - y1 )² ); // "d_ab" é a distância de (xa, ya) a (xb, yb) // "d_1b" é a distância de (x1, y1) a (xb, yb) d0 = sqrt( ( xa - x0 )² + ( ya - y0 )² ); d1 = sqrt( ( xa - x1 )² + ( ya - y1 )² ); if ( d_1b < d_ab ) { // está dentro } else if ( d0 > d1 ) { // está se aproximando } else if ( d0 < d1 ) { // está se afastando } Ou seja, se o ponto (x1, y1) estiver dentro da circunferência, a distância dele ao ponto (xb, yb) vai ser menor que o diâmetro da circunferência (que é a distância de (xa, ya) a (xb, yb)). Até mais!

Opa! Olha só, pelo que entendi, a reta "r" (o carro) parte do ponto (x0, y0) e pára no ponto (x1, y1); o prolongamento dessa trajetória cruza a cricunferência x² + y² = r² nos pontos (xa, ya) e (xb, yb). OBS.: se interpretei errado, avise. Se esse for o caso, uma possível solução para isso seria calcular a distância de (x0, y0) a (xa, ya) (chamaremos de d0), e de (x1, y1) a (xa, ya) (chamaremos de d1). d0 = sqrt( ( xa - x0 )² + ( ya - y0 )² ); d1 = sqrt( ( xa - x1 )² + ( ya - y1 )² ); if ( d0 > d1 ) { // está se aproximando } else if ( d0 < d1 ) { // está se afastando } Espero ter ajudado... Até mais!

Opa! Faça o seguinte: strcat( sRandomStr, "\n" ); Isso vai adicionar o caractere "\n" (nova linha) no final da sua string. DICA: use "fprintf", é mais simples. Por exemplo, seu código ficaria assim: ... fprintf( fPassword, "%s\n", sRandomStr ); ... Isso eliminaria a necessidade da chamada a "strcat". Até mais!

Opa! Exatamente. "fscanf" lê dados formatados de um arquivo e o armazena em uma variável; "scanf" lê dados da entrada padrão (stdin) e o armazena em uma variável. Exemplos: ... int x; scanf( "%d", &x ); /* lê um inteiro (o tipo é especificado no primeiro argumento) e o armazena na variável "x" (indicada no segundo argumento) */ ... ... FILE *f; int x, y = 3; f = fopen( "arq.dat", "w+" ); /* abre (ou cria, em caso de não existência) o arquivo para leitura e escrita */ fprintf( f, "%d", y ); /* imprime o valor de "y" no arquivo "f" */ fscanf( f, "%d", &x ); /* lê o valor inteiro armazenado no arquivo e o armazena em "x", ou seja, x = 3 */ ... Espero ter ajudado. Até mais!

Opa! Um tuto legalzinho: www.ead.eee.ufmg.br/cursos/C/. E aqui tem compiladores: http://scriptbrasil.com.br/forum/index.php?showtopic=14769. Se quiser mais, busca no Google e as dúvidas, como já foi sugerido, poste aqui. Até mais!

Opa! Posta seu código aí, ou manda pro meu e-mail: (diego.stefano@gmail.com). Até mais!

Opa! Cara, eu não sei onde encontrar isso na internet não, mas você pode criar a sua própria classe string, colocando os métodos que você precisa e sobrecarregando os operadores necessários. Se quiser ajuda, eu posso auxiliar no que você precisar. Mesmo assim vou continuar vasculhando na internet. Até mais!

Opa! A classe "string" tem um método chamado "c_str()" que retorna um "const char *" com valor da string e terminado em nulo. Até mais!

Opa! Declare a estrutura assim: struct objeto { char nome[20]; int benef; int peso; int desemp; }; Na hora de declarar um objeto dessa estrutura faça: struct objeto o; // criou-se o objeto "o" Na definição da função "qcoloca", se quer passar um objeto dessa estrutura para a função usando chamada por referência (usando ponteiros), faça: void qcoloca( struct objeto *obj ) { ... } Na hora de passar o objeto "o" que criamos anteriormente numa chamada da função: qcoloca( &o ); Se ainda tiver dúvidas, poste aí! Até mais!

Opa! Veja isso: http://scriptbrasil.com.br/forum/index.php?showtopic=40399. Até mais!

Destruidores O destruidor é o método da classe que devolve a memória alocada pelo construtor. Ele é executados toda vez que a execução sai do escopo do objeto ao qual ele pertence. A definição de um destruidor se dá da seguinte forma: ~Nome_da_classe(); Assim como os construtores, os destruidores também devem ter o mesmo nome da classe e não retornam nenhum valor. Destruidores não recebem argumentos. Vejamos o seguinte exemplo: // exemplo1.h #ifndef EXEMPLO1_H #define EXEMPLO1_H class Exemplo1 { public: Exemplo1(); // contrutor ~Exemplo1(); // destruidor }; #endif // exemplo1_1.cpp #include <iostream> #include "exemplo1.h" using namespace std; Exemplo1::Exemplo1() { cout << "Construtor do objeto 1 chamado." << endl; } Exemplo1::~Exemplo1() { cout << "Destruidor do objeto 1 chamado." << endl; } // exemplo2.h #ifndef EXEMPLO2_H #define EXEMPLO2_H class Exemplo2 { public: Exemplo2(); // contrutor ~Exemplo2(); // destruidor }; #endif // exemplo2_1.cpp #include <iostream> #include "exemplo2.h" using namespace std; Exemplo2::Exemplo2() { cout << "Construtor do objeto 2 chamado." << endl; } Exemplo2::~Exemplo2() { cout << "Destruidor do objeto 2 chamado." << endl; } // teste.cpp #include <iostream> #include "exemplo1.h" #include "exemplo2.h" using namespace std; int main() { Exemplo1 ob1; { Exemplo2 ob2; } return 0; } Esse programa imprimirá na tela as seguintes mensagens (na ordem): Isso porque o objeto 1 é instanciado primeiro, então seu construtor é chamado; depois, dentro de outro escopo (que está dentro do escopo do objeto 1, que, por sua vez, é a função "main"), o objeto 2 é criado, e seu construtor chamado. Quando a execução sai do escopo interno a "main", o destruidor do objeto 2 é chamado, pois a execução saiu do seu escopo; e, finalmente, quando a execução sai de "main", o destruidor do objeto 1 é executado. Agora, um exemplo simples de desalocação dinâmica com destruidores. // exemplo.h #ifndef EXEMPLO_H #define EXEMPLO_H class Exemplo { public: Exemplo( int = 1 ); ~Exemplo(); private: int *ePtr; }; #endif A implementação do construtor e do destruidor: #include "exemplo.h" Exemplo::Exemplo( int v ) { ePtr = new int[ v ]; } Exemplo::~Exemplo() { delete [] ePtr; } Então toda vez que um objeto dessa classe for instanciado, ele irá alocar memória dinamicamente. E toda vez que a execução deixar o escopo desse objeto, o destruidor entra em ação desalocando a memória alocada. Sacaram? Valeu, pessoas! Até a próxima!