Comportamento indefinido matou meu gato

É bem sabido que um comportamento indefinido pode matar seu gato ^{[carece de fontes?]} .
Mas pode?

Sua tarefa

1. Escreva um programa que invoque um comportamento indefinido.
2. Descreva um cenário que começa com o programa acima sendo executado, resultando em um Felus catus terminando sua vida enquanto você pertence, como resultado do UB mencionado acima.
3. Estime a probabilidade de cada estágio do cenário.
4. Calcule a probabilidade total de que uma única execução do programa mate seu gato.

Regras

1. Este é um concurso de popularidade ; portanto, seja criativo, se puder.
2. Esse é um desafio relacionado à programação; portanto, a cadeia de eventos deve estar principalmente dentro do computador, não no mundo real (é claro, se for necessário alcançar o mundo real, se é onde está o seu gato).
3. Se você escolher um idioma que não tenha um comportamento indefinido, use algo semelhante.
4. Nenhum animal pode ser prejudicado na produção de sua resposta.

Pontuação

A contagem de votos mais a probabilidade total do cenário (que não pode exceder 1).

Exemplo em C:

main(){printf();}

Cenário:

1. printfchamado com lixo da pilha - comportamento indefinido. Probabilidade: 100%.
2. O primeiro parâmetro é a string Your cat is ugly!. Probabilidade: (1/256) ¹⁷ = (1,148 * 10 ^-37 )%.
3. Vendo a mensagem, você pega sua arma e atira no seu gato. Probabilidade: 3%.
4. O gato morre. Probabilidade: 93%.

Probabilidade total: (3.202 * 10 ^-39 )%.

C

A maioria das respostas para essa pergunta interpretou mal a pergunta, pois estava matando o catprocesso em um sistema UNIX. Aqui está um programa que pode causar o desaparecimento de uma forma de vida biológica da espécie Felis Cattus, conforme especificado pela pergunta.

Este exemplo é executado no Windows, mas pode ser facilmente transportado para a maioria dos sistemas operacionais UNIX, substituindo iexplore -kpelo comando para ativar um navegador da Web instalado.

#include <stdlib.h>
#include <stdio.h>    

int main() {
    char i; // uninitialised
    printf("Redirecting you to a website which will inform you how to properly feed your cat.");
    if (i != 42) {
         system("iexplore -k https://pets.stackexchange.com/questions/tagged/cats+diet");
    } else {
         system("iexplore -k https://cooking.stackexchange.com/questions/tagged/chocolate");
    }
    return 0;
}

Este programa pretende fornecer conselhos sobre a dieta do gato ao usuário.

Ele iniciará o Internet Explorer e direcionará o usuário para troca de pilha de animais de estimação, listando muitas perguntas úteis sobre como alimentar gatos. Há, no entanto, uma chance baixa (1/256) de enviar o usuário para cozinhar a troca de pilhas, listando dicas de como preparar pratos contendo chocolate, que é altamente tóxico para gatos . Para piorar as coisas, ele iniciará o Internet Explorer no modo quiosque (tela cheia), que oculta a barra de endereços e é difícil escapar para um usuário não especialista em tecnologia.

Esse truque inteligente convencerá o usuário a alimentar o chocolate de seu gato, acreditando que é uma dieta apropriada para ele, fazendo com que ele o mate inadvertidamente.

Bater

De acordo com isso , INT_MIN % -1pode ou não ser indefinido (o que ???) e, portanto, pode causar problemas para qualquer linguagem implementada em c / c ++.

#!/bin/bash

cat <<< $((2**63%-1))

Ele catserá eliminado mais cedo se o bashprocesso pai travar, o que pode ou não ocorrer.

Na minha VM, recebo esta saída:

$ ./schroedinger.sh
./schroedinger.sh: line 3:  7805 Floating point exception(core dumped) cat <<< $((2**63/-1))
$ 

(Eu realmente não entendo a pontuação desta pergunta, mas aqui vai mesmo assim)

Calcular $((2**63%-1)). O travamento sempre acontece no bash 4.2.25, mas parece travar apenas em algumas versões 3.x. Mais incerteza. Eu poderia lhe dizer a probabilidade exata, mas devido ao princípio da incerteza de Heisenburg, eu caía em um buraco negro. Ou alguma coisa. Então, acho que podemos dizer com segurança que a probabilidade é de aproximadamente 42%.

C (ponto de sequência)

deadcat.c:

#include <stdio.h>
int main()
{
    int i=3;
    int k=0;
    k=i+(++i);
    if (k==7)
        printf("The cat is fine. k=i+(++i) =%d\n",k);
    else
        printf("Urgent Notice: Your cat has rabies. k=i+(++i) =%d\n",k);
}

Execução (ou não):

$ clang -w deadcat.c -o deadcat; ./deadcat
The cat is fine. k=i+(++i) =7
$ gcc deadcat.c -o deadcat; ./deadcat
Urgent Notice: Your cat has rabies. k=i+(++i) =8

Cenário e probabilidade

Supondo que cinco por cento das pessoas que executam este programa usem clang para compilar o código C (contra 90% usando o gcc e 5% usando outros compiladores C):

Probabilidade de obter "O gato está bem." = 0,050
 Probabilidade de obter "Aviso urgente: seu gato tem raiva". = 0,950

 Probabilidade de reagir a "Seu gato tem raiva", colocando-o para baixo = .040
 Probabilidade de ignorar o aviso = 0,900
 Probabilidade de levar o gato ao veterinário para tratamento = 0,060

 Probabilidade total de viver com gatos: .05 + .95 * (.90 + .06) = .962
 Probabilidade total de morte de um gato: .95 * .04 = .038
 Verificação: Probabilidade total de um gato viver ou morrer: = 1.000

Explicação:

k = i + (++ i) acessa e altera "i" entre pontos de sequência. A probabilidade não é determinável pelo programa; depende da escolha do compilador, que é feita pelo usuário. "Indefinido" não significa necessariamente "aleatório".

Consulte https://stackoverflow.com/questions/4176328/undefined-behavior-and-sequence-points

C

História de fundo

Minha esposa herdou um gato da família. ^† Infelizmente, sou muito alérgico a animais. A gata já tinha passado do auge e deveria ter sido sacrificada antes mesmo de a conseguirmos, mas não conseguiu livrar-se dela devido ao seu valor sentimental. Eu travei um plano para acabar com meu sofrimento.

Estávamos saindo de férias prolongadas, mas ela não queria embarcar no gato no consultório do veterinário. Ela estava preocupada com o fato de contrair doenças ou ser maltratada. Criei um alimentador automático de gatos para que pudéssemos deixá-lo em casa. Eu escrevi o firmware do microcontrolador em C. O arquivo que contém mainparecia semelhante ao código abaixo.

No entanto, minha esposa também é programadora e conhecia meus sentimentos em relação ao gato, por isso insistiu em uma revisão de código antes de concordar em deixá-lo em casa sem vigilância. Ela tinha várias preocupações, incluindo:

• main não possui uma assinatura compatível com os padrões (para uma implementação hospedada)
• main não retorna um valor
• tempTmé usado não inicializado, pois mallocfoi chamado em vez decalloc
• o valor de retorno de mallocnão deve ser convertido
• o tempo do microcontrolador pode ser impreciso ou rolar (semelhante aos problemas do tempo 2038 Y2K ou Unix)
• a elapsedTimevariável pode não ter alcance suficiente

Demorou muito para convencer, mas ela finalmente concordou que essas teses não eram problemas por várias razões (não doeu que já estávamos atrasados ​​para o nosso voo). Como não havia tempo para testes ao vivo, ela aprovou o código e saímos de férias. Quando voltamos, algumas semanas depois, a miséria do meu gato havia acabado (embora, como resultado, agora eu tenha muito mais).

^{† Cenário totalmente fictício, sem preocupações.}

Código

#include <time.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

//#include "feedcat.h"
// contains extern void FeedCat(struct tm *);
// implemented in feedcat.c
// stub included here for demonstration only
#include <stdio.h>
// passed by pointer to avoid putting large structure on stack (which is very limited)
void FeedCat(struct tm *amPm)
{
    if(amPm->tm_hour >= 12)
        printf("Feeding cat dinner portion\n");
    else
        printf("Feeding cat breakfast portion\n");
}

// fallback value calculated based on MCU clock rate and average CPI
const uintmax_t FALLBACK_COUNTER_LIMIT = UINTMAX_MAX;

int main (void (*irqVector)(void))
{
    // small stack variables
    // seconds since last feed
    int elapsedTime = 0;
    // fallback fail-safe counter
    uintmax_t loopIterationsSinceFeed = 0;
    // last time cat was fed
    time_t lastFeedingTime;
    // current time
    time_t nowTime;

    // large struct on the heap
    // stores converted calendar time to help determine how much food to
    // dispense (morning vs. evening)
    struct tm * tempTm = (struct tm *)malloc(sizeof(struct tm));

    // assume the cat hasn't been fed for a long time (in case, for instance,
    // the feeder lost power), so make sure it's fed the first time through
    lastFeedingTime = (size_t)(-1);

    while(1)
    {
        // increment fallback counter to protect in case of time loss
        // or other anomaly
        loopIterationsSinceFeed++;

        // get current time, write into to nowTime 
        time(&nowTime);

        // calculate time since last feeding
        elapsedTime = (int)difftime(nowTime, lastFeedingTime);

        // get calendar time, write into tempTm since localtime uses an
        // internal static variable
        memcpy(&tempTm, localtime(&nowTime), sizeof(struct tm));

        // feed the cat if 12 hours have elapsed or if our fallback
        // counter reaches the limit
        if(  elapsedTime >= 12*60*60 || 
             loopIterationsSinceFeed >= FALLBACK_COUNTER_LIMIT)
        {
            // dispense food
            FeedCat(tempTm);

            // update last feeding time
            time(&lastFeedingTime);

            // reset fallback counter
            loopIterationsSinceFeed = 0;
        }
    }
}

Comportamento indefinido:

Para aqueles que não querem se incomodar em encontrar o UB:

Definitivamente, há um comportamento específico do local, não especificado e definido pela implementação neste código, mas tudo deve funcionar corretamente. O problema está nas seguintes linhas de código:

struct tm * tempTm //... //... memcpy(&tempTm, localtime(&nowTime), sizeof(struct tm));
memcpysubstitui o tempTMponteiro em vez do objeto para o qual aponta, quebrando a pilha. Isso substitui, além de outras coisas, elapsedTimee loopIterationsSinceFeed. Aqui está um exemplo de execução em que imprimi os valores:

pre-smash : elapsedTime=1394210441 loopIterationsSinceFeed=1 post-smash : elapsedTime=65 loopIterationsSinceFeed=0

Probabilidade de matar o gato:

• Dado o ambiente de execução restrito e a cadeia de construção, o comportamento indefinido sempre ocorre.
• Da mesma forma, o comportamento indefinido sempre impede que o alimentador de gatos funcione como planejado (ou melhor, permite que ele "trabalhe" como planejado).
• Se o alimentador não funcionar, é extremamente provável que o gato morra. Este não é um gato que pode cuidar de si mesmo, e não pedi ao vizinho para examiná-lo.

Estimo que o gato morra com probabilidade de 0,995 .

bater

Versão clássica

cat & # This is your cat.
pkill -$RANDOM cat

Tem a vantagem de matar todos os gatos em seu alcance.

Observe que o processo é interrompido imediatamente, portanto, a única maneira de finalizá-lo com uma única chamada de pkill é enviar SIGKILL (9).

Portanto:

p(SUCCESS) = p(RANDOM == 9) = 0.0275 %

Versão quântica

schroedinger=/dev/null             # We'll need this guy.
heisenberg=/dev/urandom            # Also needed, for uncertainty principle.
cat $heisenberg > $schroedinger &  # Steal cat from Heisenberg and give it to Schrödinger.
felix=$!                           # Name cat for future references.
exec 2> $schroedinger              # Send all results to Schrödinger.
kill -SIGSTOP $felix               # Catch Felix and put him into a box.
if (($RANDOM & 1))                 # Flip a coin.
then kill $felix                   # Heads: Kill! Kill! Kill!
fi                                 # By now, Felix can be thought of as both alive and dead.
read -sn 1                         # Wait for somebody to open the box.
kill -SIGCONT $felix               # Let him open it.
if ps p $felix > $schroedinger     # Let Schrödinger check on Felix.
then echo The cat is alive.        # Hooray for tails!
else echo The cat is dead.         # At least, now we know.
fi                                 # This concludes the experiment.
kill -SIGKILL $felix               # Felix is no longer required.

Probabilidade de matar o gato durante o experimento: 50%

C

Note que isso só funciona no Linux.

main() {
  FILE *f = fopen("skynet", "w");
  srand(time(0));
  while(rand() != rand())
    fputc(rand()%256, f);
  fclose(f);
  system("chmod +x skynet");
  system("./skynet");
}

1. Grave dados aleatórios em um arquivo e invoque-os (100%)
2. Por acaso, os dados aleatórios são o código fonte do skynet (1x10 ^ -9999999999999999999999999999999999999999999999999999999999999999, aprox.)
3. Gato morre no dia do juízo final resultante (99,999%)

Probabilidade total: 1x10 ^ -99999999999999999999999999999999999999999999999999999999999999, aprox.

C ++

Seu gato está morto e vivo até que você esteja curioso. Então você percebe que há uma probabilidade de 0,5 que seu gato esteja morto.

#ifdef WIN32
#pragma warning(disable: 4700)
#endif
#include <random>
#include <iostream>
#include <vector>
#include <climits>
#include <memory>
class Cat
{
public:
    enum class State {DEAD, ALIVE};
    Cat()
    {
        int x; // Uninitialized Variable on Stack
        if (x % 2 == 0) // Is the Uninitialized Variable even? 50-50
        {
            m_dead = State::DEAD;

        }
        else
        {
            m_dead = State::ALIVE;
        }
    };
    operator State() //Check if your Cat is Dead / Alive
    {
        if (m_dead == State::DEAD)
        {
            delete this; //Boom Cat is dead
            std::cout<<"Your Curiosity killed your Cat"<<std::endl;
            return false;
        }
        return m_dead;
    }
private:
    State m_dead;
};

class Schrödinger
{
public:
    Schrödinger(size_t size):m_size(size)
    {
        for(size_t i = 0; i < size; i++)
        {
            cats.push_back(new Cat());
        }
    }
    ~Schrödinger()
    {
    }
    void Curiosity()
    {
        std::default_random_engine generator;
        std::uniform_int_distribution<int> distribution(0,m_size);
        if(*cats[distribution(generator)] == Cat::State::ALIVE)
        {
            std::cout<<"You Cat is alive and still kicking" <<std::endl;
        }
    }
private:
    std::vector<Cat *> cats;
    size_t m_size;
};
int main()
{
    int size;    
    std::cout<<"How Big is Your Example Space ?";
    std::cin>>size;
    Schrödinger your(size);
    your.Curiosity();
    return 0;

}

C

Executa no Linux.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void f(char x) {
    if(sleep(1)==x) system("killall cat");
}
int main() {
    char x; // uninitialised
    system("cat /dev/urandom &");
    f(x);
    return 0;
}

Probabilidade de matar o gato: 1/256 (O sleep(1)retorno 0, então será morto se xfor zero.)

Como bônus, mata todos os gatos atualmente em execução no seu sistema.

Se você odeia tanto gatos, apresento a você:

A Centopéia de Gato (Festança)

echo "Hello World"|cat|cat|cat

Com base no fato de que, em The Human Centopede (First Sequence) , todos os três cães da centopéia de cães morreram e duas em cada três pessoas da centopéia humana morreram, eu estimo que a probabilidade de matar um gato seja 5/6.

Javascript

~"cat".localeCompare("dead")
  ? "Cat is dead"
  : "Cat is fine"

Execução:

• Chrome: resultados em"Cat is fine"
• Firefox: Resultados em"Cat is dead"

Explicação:

15.5.4.9 String.prototype.localeCompare (that)

As duas Strings são comparadas de uma maneira definida pela implementação

Citando Glenn Randers-Pehrson, a probabilidade não é determinável pelo programa; isso depende da escolha do navegador, feita pelo usuário.

int foo() {}

void main() {
    int x = foo();
}

A leitura de um valor da função que deveria retornar um valor resulta em comportamento indefinido. Agora, é óbvio, ^{[citação necessário]} que "toda vez que você alcança um comportamento indefinido, Deus mata um gatinho". Usando isso, concluímos:

• Probabilidade de atingir um comportamento indefinido - 100%
• Probabilidade é o seu gatinho que Deus matou - 1/200 000 000 veja por que
• Portanto, a probabilidade é 0,0000005%

Pode ser facilmente estendido por loop para exterminar todos os gatos do mundo.

Java (Coleta de Lixo)

Embora o código possa chamar System.gc () is não garante que o Garbage Collector colete todos os objetos não utilizados. Assim, para o código a seguir, é imprevisível se o gato será morto ou não.

public class KillTheCat {
    public static void main(String[] args) throws InterruptedException {
        KillTheCat cat = new KillTheCat();
        cat = null;
        System.gc();
        System.out.println("Cat is still alive.");
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Cat has been killed.");
        System.exit(0);
    }
}

A probabilidade não pode ser calculada.

Observe que ainda há uma chance de o gato ser "revivido" se houver uma alternância de contexto no thread do GC após o sysout e antes do System.exit (0), mas eu preferi não cobri-lo para manter o conceito mais simples.

Alguém que pensou em realmente matar (a) cat?

[ $[ $RANDOM % 6 ] == 0 ] && rm /bin/cat || echo Meow

Probabilidade de catmorrer

Pela probabilidade ... acho que precisamos distinguir alguns casos:

1. Usuário do Windows : Provavelmente não será capaz de executá-lo. A chance de morrer cats é muito baixa, pode-se assumir com segurança zero. Se ele tiver o Cygwin instalado, ele contará como usuário unix.
2. Usuário Unix, executando sem privilégios de root : matar a catfalha.
3. Usuário Unix, executando com privilégios de root : embora cada chamada mate apenas cats com uma chance de 1/6, ele provavelmente a repetirá até que algo inesperado ocorra. Sem perda de generalidade, presumo catque definitivamente morrerá.

A probabilidade geral depende de como os usuários são misturados e é difícil de determinar. Mas certamente podemos dizer: o Windows é um local seguro para gatinhos.

Testando a obediência às regras

Nenhum animal pode ser prejudicado na produção de sua resposta.

Isso não matou animais, a resposta é aprovada pela American Humane Association .

$ file `which cat`
/bin/cat: Mach-O 64-bit executable x86_64

prova claramente que catnão é animal (desde fileque não conheça nenhum tipo de herança de tipo de arquivo oculto).

C

Se o nome do seu gato for muito longo, ele morre. getscausa mortes de gatos, juntamente com outros problemas.

#include <stdio.h>
#include <stdbool.h>

/* Stores instances of cats. */
struct cat {
    /* 6 bytes are more than enough. */
    char name[6];

    /* Stores whether your cat is dead. */
    bool dead;
};

int main(void) {
    /* This is your cat. */
    struct cat your_cat;
    /* It lives. */
    your_cat.dead = false;
    /* Determine its name. */
    printf("Your cat name: ");
    gets(your_cat.name);

    /* Output the cat state. */
    const char *state = your_cat.dead ? "dead" : "alive";
    printf("Your cat, %s, is %s.\n", your_cat.name, state);

    return your_cat.dead;
}

Haskell

import Acme.Missiles
import System.IO.Unsafe
main = print (unsafePerformIO launchMissiles, undefined)

Aqui, aplicamos unsafePerformIOa uma ação que tem efeitos colaterais observáveis . Esse é sempre um comportamento indefinido, pelo menos assim é a ordem dos efeitos. Então, ou o programa falhará primeiro ao tentar avaliar undefined(aquele, ironicamente, não é um comportamento indefinido: nunca deve gerar um valor que permita ao programa continuar com outra coisa), ou de fato incorrerá na grave crise internacional efeitos colaterais. Nesse caso, a chance de sobrevivência é de apenas 0,001% .

Probabilidade de matar o gato assim: 49.9995%.

Qui

Como a pergunta permite um idioma que não tenha um comportamento indefinido, desde que o efeito seja semelhante, escolhi Thue pelo seu não determinismo na escolha de qual regra executar quando houver mais de uma regra que pode ser aplicada na atual Estado.

O programa será alimentado no controlador por um forno de microondas, dentro do qual está o meu gato. A porta do forno micro-ondas está fechada e reforçada por uma gravata. A saída do programa decidirá se o forno de microondas começa a microondas o gato ou não.

• Se a saída for 0, iniciaremos o experimento sobre o efeito da longa exposição ao microondas em mamíferos vivos (que atualmente não é suficientemente pesquisado).
• Se o resultado for 1, ficaremos satisfeitos com o fato de o gato ter acabado de perder uma de suas 9 vidas e liberado.

i::=~0
i::=~1
::=
i

A probabilidade de matar o gato depende da implementação do intérprete, mas digamos que seja 50%. Então a probabilidade de o gato morrer é 0,5 .

Java

De acordo com as especificações, java.util.Date terá um comportamento indefinido. Então tente a sua sorte:

import java.util.Date;

public class App3
{
    public static void main (String args[])
    {
        String aliveOrDead;
        Date d = new Date(-1000,-1000,-1000);
        aliveOrDead = (d.getTime()<0)? "dead" : "alive";
        System.out.println("The cat is:" +aliveOrDead );
    }
}