Portas ou circuitos lógicos são dispositivos que operam e trabalham com um ou mais sinais lógicos de entrada para produzir uma e somente uma saída, dependente da função implementada no circuito.

As situações “Verdade” e “Falso” são estudadas na Lógica Matemática ou Lógica de Boole. Existem as seguintes portas lógicas: AND, OR e NOT são as principais, pois com elas podemos formar as demais que são: NAND, NOR , XOR e XNOR .

Lembrando que ao analisar saída de execução: 0 é verdadeiro(sem erro) e 1 é falso( >= 1 é erro), então isso pode confundir sua mente ao analisar os exemplos, pois é o contrário, mas eu não vou inverter porque é assim que é na realidade, então vamos usar o conceito de computação e não de saída de execução: 0 como falso e 1 é verdadeiro . 😃

AND logical_and

Essa porta resulta em um valor lógico verdadeiro somente se todos os operados tem um valor verdadeiro( nesse caso é 1 ). Uma idéia de entendimento seria dois interruptores ligados em série ) e uma lâmpada no final, ou seja, a lâmpada só será ligada se esses dois interruptores estiverem ligados.

Para esses exemplos usaremos a função std::transform . Vamos analizar a saída da combinação de dois arrays usando a std::logical_and:

#include <iostream>
#include <algorithm>

int main(){
    const int num = 3;
    bool array1[] = { false, false, true },
         array2[] = { false, true, true },
         result[ num ];

    std::transform( array1, array1 + num, array2, result, std::logical_and<bool>());

    std::cout << "Lógica AND:\n";
    for (int i = 0; i < num; ++i){
      std::cout << array1[i] << " AND " << array2[i] << " = " << result[i] << "\n";
    }
    return 0;
}

A saída será:

0 AND 0 = 0
0 AND 1 = 0
1 AND 1 = 1

Caso queira ver a saída literal, use assim:

#include <iostream>
#include <algorithm>

int main(){
    const int num = 3;
    bool array1[] = { false, false, true },
         array2[] = { false, true, true },
         result[ num ];
    const char * vf;

    std::transform( array1, array1 + num, array2, result, std::logical_and<bool>());

    std::cout << "Lógica AND:\n";
    for (int i = 0; i < num; ++i){
       vf = ( result[i] == 0 ? "false" : "true" );
      std::cout << array1[i] << " AND " << array2[i] << " = " << vf << "\n";
    }
    return 0;
}

A saída será:

Lógica AND:
0 AND 0 = false
0 AND 1 = false
1 AND 1 = true

Ou seja, igual ao exemplo das lâmpadas, somente se ambos for verdadeiro que a saída é verdadeira!

NOT logical_not

A Porta NOT ou inversora é uma porta lógica digital que implementa a negação lógica, de acordo com a tabela verdade abaixo. Ou seja, se for falso ele retorna true e se for true ele retorna false.

Nesse exemplo usaremos somente um array(somente com 2 elementos) e lógico só passaremos 4 parametros para o std::transform.

#include <iostream>
#include <algorithm>

int main(){
    const int num = 2;
    bool array1[] = { false, true },
         result[ num ];
    const char * vf;

    std::transform( array1, array1 + num, result, std::logical_not<bool>());

    std::cout << "Lógica NOT:\n";
    for (int i = 0; i < num; ++i){
       vf = ( result[i] == 0 ? "false" : "true" );
      std::cout << array1[i] << " NOT" << " = " << vf << "\n";
    }
    return 0;
}

A saída será:

Lógica NOT:
0 NOT = true
1 NOT = false

OR logical_or

A porta lógica OR também é chamada de disjunção lógica, é uma operação lógica entre dois ou mais operandos que resulta em um valor lógico falso se, e somente se, todos os operandos tiverem um valor falso.

Ou seja, se todos os valores forem falsos será falso, caso contrário será verdadeiro.

Retornando o exemplo de analisar 2 arrays.

#include <iostream>
#include <algorithm>

int main(){
    const int num = 3;
    bool array1[] = { false, false, true },
         array2[] = { false, true, true },
         result[ num ];
    const char * vf;

    std::transform( array1, array1 + num, array2, result, std::logical_or<bool>());

    std::cout << "Lógica OR:\n";
    for (int i = 0; i < num; ++i){
       vf = ( result[i] == 0 ? "false" : "true" );
      std::cout << array1[i] << " OR " << array2[i] << " = " << vf << "\n";
    }
    return 0;
}

A saída será:

Lógica OR:
0 OR 0 = false
0 OR 1 = true
1 OR 1 = true

Por hoje é só, são pequenas doses diárias que farão sempre nos manter antenado com o C++ !

Acompanhe o cpp::daily

Deseja aprender C++ e criar seus programas Gráficos e para Terminal com portabilidade para Linux e Windows?

Então se inscreva nos nossos Cursos de C++ Moderno . Você aprender criar:

• Games
• Ncurses
• Interface Gráfica: GTK+ e Qt
• Acesso à Banco de Dados(MySQL e SQLite) via C++
• Padronização
• E muito mais!

Acesse o endereço:

https://terminalroot.com.br/cpp/ e saiba mais!

Links Úteis

• https://en.wikipedia.org/wiki/Logic_gate
• https://en.wikipedia.org/wiki/AND_gate
• https://en.cppreference.com/w/cpp/utility/functional/logical_and
• https://en.wikipedia.org/wiki/NOT_gate
• http://www.cplusplus.com/reference/functional/logical_or/
• https://en.wikipedia.org/wiki/OR_gate

cppdaily cpp

Marcos Oliveira

Desenvolvedor de software

https://github.com/terroo