quinta-feira, 8 de outubro de 2020
Container multiset - declarando e inicializando
terça-feira, 6 de outubro de 2020
Container set - declarando e inicializando
- Um set pode ser considerado semelhante
- a um recipiente ou um conjunto matemático.
- Por ser um repositório Associativo,
- jamais permite valores duplicados em sua interface,
- e os elementos são automaticamente ordenados
- de forma ascendente, eliminando duplicatas se houver.
- Um set só permite objetos de um mesmo tipo,
- que deve ser especificado no seu corpo em sua declaração.
- Uma vez armazenados, os objetos são do tipo key,
- que são chaves de valores constantes e que não se pode alterar.
- Se for preciso alterar um valor dentro de um set,
- precisamos primeiro excluir um elemento,
- para depois inserir outro em seu lugar,
- respeitando o tipo especificado no seu corpo.
- A parte teórica dos sets em C++ é um tanto extensa,
- mas não vejo nada mais necessário de apresentar,
- além do que já escrevemos aqui, mesmo porque
- o grau de dificuldade de usar os sets é quase 0,
- e isto é um privilégio para nós que estamos envolvidos com C++.
- No exemplo mostrado aqui, criamos um array do tipo string
- especial do C++ Builder, mas que poderia ser do tipo
- string padrão do C++, este array foi inicializado
- com algumas string em forma de frase, com algumas
- repetidas e desordenadas.
- Na impressão da esquerda imprimimos o array
- como foi criado, e na impressão da direita
- temos o set imprimido com seus elementos
- ordenados e sem as frases repetidas do array de string.
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <System.Classes.hpp>
#include <Vcl.Controls.hpp>
#include <Vcl.StdCtrls.hpp>
#include <Vcl.Forms.hpp>
#include <Vcl.Buttons.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed Components
TLabel *Label1;
void __fastcall Informe ( TObject *Sender );
void __fastcall Label_Manual ( TObject *Sender );
void __fastcall FormPaint ( TObject *Sender );
void __fastcall FormShow(TObject *Sender);
private: // User declarations
public: // User declarations
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
quinta-feira, 1 de outubro de 2020
C++ builder - Array e o metodo random_shuffle
Logo no primeiro contato que tivemos
com o array do C++ observamos logo
que o mesmo não é tão diferente do
Array do C, apesar de possuir mais recursos,
e de possuir grande eficiência especialmente
para tamanhos pequenos, como os Arrays do C.
Estes arrays estão entre os vários
contêiner do C++ e possui tamanho fixo
especificado em tempo de execução.
São capazes de suportar iteradores
em acesso aleatórios, e possui alguns
métodos interessantes, que por enquanto
não vamos comentar exceto este que está
sendo usado pelo programa, a saber,
o método std::random_shuffle ( &a [ 0 ], &a [ 100 ] );
o método std::random_shuffle, trabalha organizando
seus elementos em base de troca,
cuidadosamente ele verifica quem vem primeiro
e quem vem depois, baseado no menor e no maior,
vai comparando e organizando aleatoriamente.
Me lembro que no início de nossa formação em C,
passávamos horas criando rotinas para embaralhar
elementos inteiros em Vetores e matrizes bidimensionais,
mas os estudantes de C++ tem o privilégio de usar
este poderoso método em seus programas com muita facilidade.
terça-feira, 8 de setembro de 2020
C++ builder - capturando coordenadas do form II
C++ builder - capturando coordenadas do form
C++ builder - Variáveis signed e unsigned
que são dois modificadores de tipos muito útil aos programadores,
desta importante linguagem.
A finalidade destes modificadores é de rejeitar
valores que não serão aceitos em nosso programa.
Os tipos inteiros e os ( char ), aceitam normalmente
valores negativos ou positivos,
mas se na declaração destes tipos for antecedido
com o modificador unsigned, só podemos fazer uso
de números iguais ou maiores que zero.
Programadores podem querer tentar atribuir valores
acima do que uma variável possa suportar,
já adiantamos que se uma variável for excedida,
sendo declarada com unsigned, seus valores
continuarão a partir do zero, até o máximo
que a variável possa suportar, e se chegar
no seu extremo voltará novamente para o zero.
mas se for do tipo modificador signed,
seus valores serão armazendos,
a partir do menor valor negativo ( -1 ).
até o máximo que a variável possa suportar,
e se chegar no seu extremo voltará novamente para o zero.
Então nestas linhas aprendemos que uma variável unsigned,
não aceita valores negativos, e no exemplo passado aqui,
podemos ver isto com muita clareza.
Declaramos duas variáveis, e inicializamos as mesmas,
com o mesmo valor ( 10 ), uma do tipo char com unsigned,
cujos valores ficam restrito entre ( 0 e 255 ),
que é justamente o dobro dos valores máximos de uma variável
char sem sinal ( -128 a 127 ).
e a outra variável também do tipo char declarada
com signed ( com sinal ).
Assista agora atentamente este vídeo,
e acesse o link para apreciação do código,
não leve em conta as diversas linhas atribuída
a interface gráfica, sobrou um pouco de tempo
segunda-feira, 7 de setembro de 2020
STRCHR - Pesquisando caractere numa string
em busca da primeira ocorrência de um caractere.
strchr retorna um ponteiro para a primeira ocorrência
do caractere procurado na string,
se o caractere não ocorre na string, strchr retorna nulo.
Leve em conta o terminador nulo como parte da string.