Você está aqui: C++ ::: Win32 API (Windows API) ::: Arquivos e Diretórios

Entenda e aprenda a usar a função CreateFile() da API do Windows

Quantidade de visualizações: 10648 vezes
A função CreateFile() é usada para criar ou abrir arquivos existentes para leitura, escrita ou ambos. Veja seu protótipo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

HANDLE WINAPI CreateFile(
  LPCTSTR lpFileName,
  DWORD dwDesiredAccess,
  DWORD dwShareMode,
  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  DWORD dwCreationDisposition,
  DWORD dwFlagsAndAttributes,
  HANDLE hTemplateFile
);

Esta é uma das funções mais complexas da Win32 API, devido ao seu grande números de opções. É claro que podemos alcançar os resultados mais comuns simplesmente aceitando os valores padrões. Assim, vou detalhar os valores mais importantes para cada um dos parâmetros.

a) LPCTSTR lpFileName - Este é o nome do arquivo a ser criado ou aberto.

b) DWORD dwDesiredAccess - Aqui podemos definir o modo no qual o arquivo será aberto. Para leitura usamos o valor GENERIC_READ e para escrita o valor GENERIC_WRITE. Se quisermos abrir o arquivo tanto para leitura quanto para escrita podemos usar o operador bit-wise "|" para combinar os valores anteriores: GENERIC_READ | GENERIC_WRITE.

c) DWORD dwShareMode - Define o modo de compartilhamento do arquivo, que pode ser leitura, escrita, ambos ou nenhum. Geralmente usamos o valor 0 para este parâmetro, o que significa que o arquivo não pode ser compartilhado ou aberto novamente até que liberemos o HANDLE obtido. Outros valores possíveis são: FILE_SHARE_DELETE, FILE_SHARE_READ e FILE_SHARE_WRITE.

d) LPSECURITY_ATTRIBUTES lpSecurityAttributes - Um ponteiro para uma estrutura SECURITY_ATTRIBUTES que define se o handle retornado pode ser herdado por processos filhos. Em geral usamos NULL para este parâmetro, o que significa que o handle não pode ser herdado.

e) DWORD dwCreationDisposition - A ação a ser tomada no arquivo existente ou não existente. Os valores possíveis são:

CREATE_ALWAYS - Sempre cria um novo arquivo. Se este existir, seu conteúdo é apagado.
CREATE_NEW - Cria um novo arquivo. Se o arquivo já existir a função falha.
OPEN_ALWAYS - Sempre abre o arquivo. Se este não existir, a função CreateFile() o criará.
OPEN_EXISTING - Abre um arquivo. A função falhará se o arquivo não existir.
TRUNCATE_EXISTING - Abre um arquivo existente e apaga seu conteúdo, de forma a deixá-lo com o tamanho de 0 bytes. Se o arquivo não existir a função falha.

f) DWORD dwFlagsAndAttributes - Define os atributos e flags do arquivo. Em geral usamos o valor FILE_ATTRIBUTE_NORMAL para este parâmetro. Este valor indica que o arquivo não possui outros atributos definidos.

g) HANDLE hTemplateFile - Um handle para um arquivo de template com o direito de acesso GENERIC_READ. Em geral fornecemos o valor NULL para este parâmetro.

Se a função CreateFile() obter sucesso, o valor retornado é um HANDLE para o arquivo especificado. Em caso de falha, o valor retornado é INVALID_HANDLE_VALUE. Para obter mais informações sobre o motivo da falha, basta efetuarmos uma chamada à GetLastError().

Veja um trecho de código no qual abrimos o arquivo chamado testes.txt para leitura. Se o arquivo não existir, a função CreateFile() o criará:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <cstdlib>
#include <iostream>
#include <windows.h>

using namespace std;

int main(int argc, char *argv[]){
  // nome do arquivo
  CHAR arquivo[] = "C:\\testes.txt";
  
  HANDLE hArquivo = CreateFile(arquivo, GENERIC_READ, 0, NULL,
    OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  if(hArquivo == INVALID_HANDLE_VALUE){
    cout << "Erro ao abrir o arquivo: " << GetLastError() << endl;    
  }
  else{
    cout << "Arquivo aberto com sucesso." << endl;   
  }
    
  // vamos fechar o handle
  CloseHandle(hArquivo);
  
  system("PAUSE");
  return EXIT_SUCCESS;
}

Execute este arquivo e verá um arquivo testes.txt ser criado com o tamanho de 0 bytes caso este ainda não exista no caminho especificado.

Link para compartilhar na Internet ou com seus amigos:

C++ ::: Dicas & Truques ::: Strings e Caracteres

Como substituir todas as ocorrências de uma substring em uma string C++ usando uma função substituir_string() personalizada

Quantidade de visualizações: 10276 vezes
Nesta dica mostrarei como podemos tirar proveito das funções empty(), size(), find(), replace() e length() da classe String do C++ para escrever uma função substituir_string() personalizada que nos permite substituir todas as ocorrências de uma substring em uma string.

Veja o código C++ completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <string>
#include <iostream>

using namespace std;

// função personalizada para substituir todas as ocorrências
// de uma substring em uma string
void substituir_string(string& str, const string de, 
  const string para){
  
  // variáveis auxiliares
  int i = 0, indice;
  
  // a string está vazia?
  if(str.empty()){
    str = de;
    return;
  }
  
  // fazemos as substituições da substring
  while(i < str.size()){
    indice = str.find(de, 0);
    
    if(indice >= 0){ 
      str.replace(indice, de.length(), para);
    }
    else{
      return;
    }
	
    i++;
  }
}

// função principal do programa
int main(int argc, char *argv[]){
  // vamos criar uma string
  string frase = "Java? Gosto de Java, Java!";
  cout << "A frase original é: " << frase << endl;	
	
  // Substitui as ocorrências de "Java" por "PHP"
  substituir_string(frase, "Java", "PHP"); 
	 
  // e mostramos o resultado	 
  cout << "Depois da substituição: " << frase << endl; 
	 
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Ao executar este código C++ nós teremos o seguinte resultado:

A frase original é Java? Gosto de Java, Java!
Depois da substituição: PHP? Gosto de PHP, PHP!


C++ ::: Dicas & Truques ::: MIDI Musical Instrument Digital Interface, Mapeamento e sequenciamento MIDI, Entrada e saída MIDI

Como definir o tipo de instrumento (programa) em um evento MIDI e enviar a mensagem para a função midiOutShortMsg() da API Win32 do Windows

Quantidade de visualizações: 986 vezes
Vimos em dicas nessa seção como usar a função midiOutShortMsg() da API Win32 do Windows para tocar notas musicais no dispositivo de saída MIDI. No entanto, nos exemplos anteriores, a nota tocada foi no instrumento padrão, ou seja, Acoustic Grand Piano, e no canal 1.

Nesta dica mostrarei como definir o instrumento e também falarei um pouco mais sobre como tocar as notas em canais diferentes. Vamos então, com muita atenção.

Analisando a documentação MIDI, encontramos que uma mudança de programa (instrumento musical) no canal 1 é representada pelo código de status 192 (hexadecimal C0), seguido pelo código do instrumento a ser usado (um valor inteiro que vai de 0 a 127, e que deverá ser convertido em hexadecimal). Assim, é bom dar uma olhada nessa lista:

Piano Timbres:

 1	Acoustic Grand Piano
 2	Bright Acoustic Piano
 3	Electric Grand Piano
 4	Honky-tonk Piano
 5	Rhodes Piano
 6	Chorused Piano
 7	Harpsichord
 8	Clavinet

Chromatic Percussion:
 9	Celesta
10	Glockenspiel
11	Music Box
12	Vibraphone
13	Marimba
14	Xylophone
15	Tubular Bells
16	Dulcimer

Organ Timbres:
17	Hammond Organ
18	Percussive Organ
19	Rock Organ
20	Church Organ
21	Reed Organ
22	Accordion
23	Harmonica
24	Tango Accordion
 
Guitar Timbres:
25	Acoustic Nylon Guitar
26	Acoustic Steel Guitar
27	Electric Jazz Guitar
28	Electric Clean Guitar
29	Electric Muted Guitar
30	Overdriven Guitar
31	Distortion Guitar
32	Guitar Harmonics

Bass Timbres:
33	Acoustic Bass
34	Fingered Electric Bass
35	Plucked Electric Bass
36	Fretless Bass
37	Slap Bass 1
38	Slap Bass 2
39	Synth Bass 1
40	Synth Bass 2

String Timbres:
41	Violin
42	Viola
43	Cello
44	Contrabass
45	Tremolo Strings
46	Pizzicato Strings
47	Orchestral Harp
48	Timpani
 
Ensemble Timbres:
49	String Ensemble 1
50	String Ensemble 2
51	Synth Strings 1
52	Synth Strings 2
53	Choir "Aah"
54	Choir "Ooh"
55	Synth Voice
56	Orchestral Hit

Brass Timbres:
57	Trumpet
58	Trombone
59	Tuba
60	Muted Trumpet
61	French Horn
62	Brass Section
63	Synth Brass 1
64	Synth Brass 2

Reed Timbres:
65	Soprano Sax
66	Alto Sax
67	Tenor Sax
68	Baritone Sax
69	Oboe
70	English Horn
71	Bassoon
72	Clarinet
 
Pipe Timbres:
73	Piccolo
74	Flute
75	Recorder
76	Pan Flute
77	Bottle Blow
78	Shakuhachi
79	Whistle
80	Ocarina

Synth Lead:
81	Square Wave Lead
82	Sawtooth Wave Lead
83	Calliope Lead
84	Chiff Lead
85	Charang Lead
86	Voice Lead
87	Fifths Lead
88	Bass Lead

Synth Pad:
89	New Age Pad
90	Warm Pad
91	Polysynth Pad
92	Choir Pad
93	Bowed Pad
94	Metallic Pad
95	Halo Pad
96	Sweep Pad
 
Synth Effects:
 97	Rain Effect
 98	Soundtrack Effect
 99	Crystal Effect
100	Atmosphere Effect
101	Brightness Effect
102	Goblins Effect
103	Echoes Effect
104	Sci-Fi Effect

Ethnic Timbres:
105	Sitar
106	Banjo
107	Shamisen
108	Koto
109	Kalimba
110	Bagpipe
111	Fiddle
112	Shanai

Sound Effects:
113	Tinkle Bell
114	Agogo
115	Steel Drums
116	Woodblock
117	Taiko Drum
118	Melodic Tom
119	Synth Drum
120	Reverse Cymbal
 
Sound Effects:
121	Guitar Fret Noise
122	Breath Noise
123	Seashore
124	Bird Tweet
125	Telephone Ring
126	Helicopter
127	Applause
128	Gun Shot

A especificação MIDI define que o canal 10 seja reservado
para os kits de percussão. Os instrumentos abaixo possuem
os números de notas a serem enviados neste canal.

35	Acoustic Bass Drum
36	Bass Drum 1
37	Side Stick
38	Acoustic Snare
39	Hand Clap
40	Electric Snare
41	Low Floor Tom
42	Closed High Hat
43	High Floor Tom
44	Pedal High Hat
45	Low Tom
46	Open High Hat
47	Low Mid Tom
48	High Mid Tom
49	Crash Cymbal 1
50	High Tom
51	Ride Cymbal 1
52	Chinese Cymbal
53	Ride Bell
54	Tambourine
55	Splash Cymbal
56	Cowbell
57	Crash Cymbal 2
58	Vibraslap
59	Ride Cymbal 2
60	High Bongo
61	Low Bongo
62	Mute High Conga
63	Open High Conga
64	Low Conga
65	High Timbale
66	Low Timbale
67	High Agogo
68	Low Agogo
69	Cabasa
70	Maracas
71	Short Whistle
72	Long Whistle
73	Short Guiro
74	Long Guiro
75	Claves
76	High Wood Block
77	Low Wood Block
78	Mute Cuica
79	Open Cuica
80	Mute Triangle
81	Open Triangle


É uma lista bem longa e ficará a ser cargo estudá-la ou usá-la como referência. Meu interesse maior é o código C/C++. Assim, vamos ver logo como definir o instrumento no canal 1 como Overdriven Guitar. Este instrumento possui o código 30 mas, na programação, devemos diminuí-lo em 1, ficando 29, e, ao passarmos para hexadecimal teremos 1D.

A mudança de programa no canal 1 é representada pelo código 192, o que em hexadecimal é C0. Pronto, agora basta construirmos o DWORD da forma que fizemos nas dicas anteriores e chamar a função midiOutShortMsg(). Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <cstdlib>
#include <iostream>
#include <windows.h>

using namespace std;

int main(int argc, char *argv[]) {
  unsigned int erro; // guarda o erro caso algo dê errado
  HMIDIOUT saida; // handle para o dispositivo de saída MIDI.

  // vamos abrir o dispositivo de saída MIDI
  erro = midiOutOpen(&saida, MIDI_MAPPER, 0, 0, CALLBACK_NULL);
  if (erro != MMSYSERR_NOERROR) {
    printf("Não foi possível abrir o mapeador MIDI: %d\n", erro);
  }
  else {
    printf("Mapeador MIDI aberto com sucesso\n");
  }

  // vamos definir o instrumento como Overdriven Guitar
  // no canal 1
  midiOutShortMsg(saida, 0x00001DC0);

  // vamos tocar o dó central com velocidade 100
  midiOutShortMsg(saida, 0x00643C90);
  Sleep(1000); // a nota vai durar 1 segundo
  // dispara a mensagem Note-off
  midiOutShortMsg(saida, 0x00643C80);

  // agora vamos fechar o dispositivo de saída MIDI
  midiOutClose(saida);

  system("PAUSE");
  return EXIT_SUCCESS;
}


Execute esse código e ouça um nota dó sendo tocada na guitarra com uma linda distorção. Se você quiser tocar a nota nó no canal 2 ou canal 3, basta usar C1, C2, e assim por diante. Uma última observação é você ficar atento ao fato de que os códigos de Note-on e Note-off para o canal 1 é 90 e 80 (em hexadecimal). Se for no canal 2, os códigos correspondentes serão 91 e 81 (sempre em hexadecimal).


C++ ::: Dicas & Truques ::: Strings e Caracteres

Como retornar o tamanho de uma string em C++ usando a função size()

Quantidade de visualizações: 7983 vezes
Nesta dica mostrarei como podemos obter a quantidade de caracteres de uma string em C++ usando a função size() da classe string. Esta função não exige nenhum argumento e retorna um número inteiro contendo a quantidade de caracteres na string.

Veja o código C++ completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <string>
#include <iostream>
 
using namespace std;
 
// função principal do programa C++ 
int main(int argc, char *argv[]){
  // vamos declarar um objeto string
  string frase = "Gosto de C++";
 
  // vamos obter o tamanho da string
  size_t tamanho = frase.size();
  
  // e mostramos o resultado
  cout << "A frase possui " << tamanho << " caracteres."; 
     
  cout << "\n" << endl;	    
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Ao executarmos este código C++ nós teremos o seguinte resultado:

A frase possui 12 caracteres.


Desafios, Exercícios e Algoritmos Resolvidos de C++

Veja mais Dicas e truques de C++

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 67 usuários muito felizes estudando em nosso site.