Você está aqui: C++ ::: Dicas & Truques ::: MIDI Musical Instrument Digital Interface, Mapeamento e sequenciamento MIDI, Entrada e saída MIDI

Aprenda a usar a função midiOutOpen() do Windows para abrir o dispositivo de saída MIDI

Quantidade de visualizações: 1127 vezes
Antes de tocarmos uma nota MIDI ou até mesmo um grupo de eventos MIDI, precisamos entender como abrir o dispositivo de saída MIDI. Para isso podemos usar a função midiOutOpen() da API do Windows. Essa função possui a seguinte assinatura:

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

MMRESULT midiOutOpen(
  LPHMIDIOUT phmo,
  UINT       uDeviceID,
  DWORD_PTR  dwCallback,
  DWORD_PTR  dwInstance,
  DWORD      fdwOpen
);

O parâmetro LPHMIDIOUT aponta para um handle do tipo HMIDIOUT, o qual nos permite identificar o dispositivo MIDI aberto.

O parâmetro uDeviceID identifica a saída MIDI que vai ser aberta.

O parâmetro dwCallback representa uma função de callback ou um gerenciador de eventos.

O parâmtro dwInstance representa dados de instância do usuário para a função de callback.

O parâmetro fdwOpen é uma flag de callback para abrir o dispositivo. Os valores válidos são: CALLBACK_EVENT, CALLBACK_FUNCTION, CALLBACK_NULL, CALLBACK_THREAD e CALLBACK_WINDOW.

Veja um trecho de código no qual usamos a função midiOutOpen() para abrir o dispositivo de saída MIDI e então usamos midiOutClose() para fechá-lo. Não se esqueça que você precisa do Windows SDK instalado. Para este exemplo eu usei o Visual Studio 2017 (com a biblioteca winmm.lib referenciada nas dependências adicionais de entrada do veiculador - linker).

----------------------------------------------------------------------
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");
  }

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

  system("PAUSE");
  return EXIT_SUCCESS;
}

Veja que aqui eu forneci o valor MIDI_MAPPER para o parâmetro uDeviceID. MIDI_MAPPER representa o dispositivo padrão. Porém, se você tiver mais de um dispositivo de saída MIDI instalado, poderá referenciá-los pelos valores 0, 1, 2, 3, etc.

Execute o código e veja o resultado. Se você vir a mensagem "Mapeador MIDI aberto com sucesso" então seu dispositivo de saída MIDI foi acessado e está pronto para receber mensagens.

Link para compartilhar na Internet ou com seus amigos:

C++ ::: Fundamentos da Linguagem ::: Tipos de Dados

Como usar o tipo de dados long ou long int da linguagem C++

Quantidade de visualizações: 22378 vezes
O tipo de dados long (também chamado de long int) da linguagem C++ é uma variação do tipo int e geralmente possui a mesma capacidade de armazenamento deste. Nós o usamos quando queremos representar números inteiros, ou seja, sem partes fracionárias, assim como int. É importante verificar se o seu compilador trata int e long da mesma forma. Veja um trecho de código demonstrando o uso deste tipo (note que estes estudos foram feitos no Windows XP - 32 bits - usando Dev-C++):

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

#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  // declara uma variável do tipo long
  long quant = 590;

  cout << "Quantidade: " << quant << "\n\n";

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Veja que a maioria dos compiladores C++ não faz distinção entre os tipos long e long int. A capacidade de armazenamento do tipo long depende da arquitetura na qual o programa está sendo executado. Uma forma muito comum de descobrir esta capacidade é usar os símbolos LONG_MIN e LONG_MAX, definidos no header climits (limits.h). Veja:

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

#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  cout << "Valor mínimo: " << LONG_MIN << "\n";
  cout << "Valor máximo: " << LONG_MAX << "\n\n";

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Ao executar este programa você terá um resultado parecido com:

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

Valor mínimo: -2147483648
Valor máximo: 2147483647

Veja que o tipo long aceita valores positivos e negativos. Tudo que você tem a fazer é tomar todo o cuidado para que os valores atribuidos a variáveis deste tipo não ultrapassem a faixa permitida. Veja um trecho de código que provoca o que chamamos de transbordamento (overflow):

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

#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  long soma = LONG_MAX + 2;

  cout << "Resultado: " << soma << "\n";

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Este programa exibirá o seguinte resultado:

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

Resultado: -2147483647

Note que este não é o resultado esperado, visto que LONG_MAX + 2 deveria retornar:

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

2147483647 + 2 = 2147483649

Porém, como o valor máximo que pode ser armazenado em um long é 2147483647, o procedimento adotado pelo compilador foi tornar o número negativo e subtrair 1. É claro que, se você testar este código em arquiteturas diferentes o resultado poderá ser diferente do exemplificado aqui.

Em termos de bytes, é comum o tipo long ser armazenado em 4 bytes, o que resulta em 32 bits (um byte é formado por 8 bits, lembra?). Veja um trecho de código que mostra como usar o operador sizeof() para determinar a quantidade de bytes necessários para armazenar um variável do tipo long:

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

#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  cout << "Tamanho de um long: " << sizeof(long)
    << " bytes\n\n";

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

O resultado da execução deste código será algo como:

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

Tamanho de um long: 4 bytes



C++ ::: Dicas & Truques ::: Arquivos e Diretórios

Arquivos e diretórios em C++ - Como excluir um arquivo usando a função remove() do C++

Quantidade de visualizações: 10339 vezes
Em algumas situações nossos códigos C++ precisam excluir arquivos. Isso pode ser feito com o auxílio da função remove() ou _remove(), disponível no header io.h or stdio.h (trazido da linguagem C). Veja a assinatura desta função:

int remove(const char *filename);


Se o arquivo for excluído com sucesso a função retornará o valor 0. O retorno será -1 se um erro ocorrer. Neste caso a variável global errno será definido como um dos seguintes valores:

a) ENOENT - No such file or directory - O caminho do arquivo é inválido;

b) EACCESS - Acesso negado - Algum outro programa está usando este arquivo e mantém controle sobre o mesmo.

Veja um trecho de código no qual excluimos um arquivo:

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

#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  // vamos excluir este arquivo
  char arquivo[] = "C:\\Dev-Cpp\\arquivo.txt";

  // vamos testar se o arquivo foi excluído com sucesso
  if(remove(arquivo) != 0){
    cout << "Erro: " << strerror(errno) << endl;
  }
  else{
    cout << "Arquivo excluído com sucesso" << endl;
  }

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

É possível usar a versão Unicode de remove(). O método _wremove(), também presente em io.h or stdio.h é útil quando precisamos internacionalizar nossas aplicações. Veja o exemplo:

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

#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  // vamos excluir este arquivo
  wchar_t arquivo[] = L"C:\\Dev-Cpp\\arquivo.txt";

  // vamos testar se o arquivo foi excluído com sucesso
  if(_wremove(arquivo) != 0){
    cout << "Erro: " << strerror(errno) << endl;
  }
  else{
    cout << "Arquivo excluído com sucesso" << endl;
  }

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

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

Arquivo excluído com sucesso.


C++ ::: Fundamentos da Linguagem ::: Estruturas de Controle

Como usar ponteiros para controlar um laço while em C++

Quantidade de visualizações: 9263 vezes
É possível usar ponteiros para controlar a execução de um laço while em C++. Comece analisando o seguinte trecho de código:

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

// uma matriz de caracteres
char nome[] = "Arquivo";

// aponta para a primeira letra
char *letra = nome;

if(*letra)
  cout << "True";
else
  cout << "False";

Aqui o valor "True" será exibido, visto que o ponteiro *letra está apontando para um local da matriz de caracteres nome[] que é diferente de NULL. Veja agora:

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

// uma matriz de caracteres
char nome[] = "Arquivo";

// aponta para a primeira letra
char *letra = nome; // posição 0

// vamos atingir o final da matriz
// de caracteres
letra++; // posição 1
letra++; // posição 2
letra++; // posição 3
letra++; // posição 4
letra++; // posição 5
letra++; // posição 6
letra++; // NULL

if(*letra)
  cout << "True";
else
  cout << "False";

Como sabemos que a matriz de caracteres nome[] contém sete caracteres (de 0 a 6), incrementamos o ponteiro *letra até que este aponte para o caractere que marca o fim da matriz. Assim, o valor "False" é exibido.

Veja agora um laço while que tira proveito do que vimos aqui para exibir as letras da palavra "Arquivo" separadamente usando um ponteiro:

----------------------------------------------------------------------
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;

int main(int argc, char *argv[]){
  // uma matriz de caracteres
  char nome[] = "Arquivo";

  // aponta para a primeira letra
  char *letra = nome;

  // vamos usar o laço while para
  // imprimir as letras separadamente
  while(*letra){
    cout << *letra << " ";
    letra++;
  }

  cout << "\n\n";

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}



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á 69 usuários muito felizes estudando em nosso site.