不确定的行为杀死了我的猫

众所周知，不确定的行为会杀死猫^{[需要引用]}。
但是可以吗？

你的任务

1. 编写一个调用未定义行为的程序。
2. 描述一种情况，该情况从上述程序的运行开始，由于前面提到的UB ，导致Felis catus在您拥有时终止其寿命。
3. 估计方案​​中每个阶段的概率。
4. 计算该程序一次运行会杀死猫的总概率。

规则

1. 这是一场人气竞赛，因此，如果可以的话，请发挥创意。
2. 这是与编程相关的挑战，因此事件链应该主要在计算机内部，而不是在真实世界中（当然，如果那是猫的所在，那么必须到达真实世界）。
3. 如果您选择的语言没有未定义的行为，请使用类似的语言。
4. 出示答案时，不会对动物造成伤害。

计分

投票数加上方案的总概率（不能超过1）。

在C中的示例：

main(){printf();}

场景：

1. printf从堆栈中调用垃圾-未定义行为。机率：100％。
2. 第一个参数恰好是字符串Your cat is ugly!。概率：（1/256）¹⁷ =（1.148 * 10 ^-37）％。
3. 看到消息后，您拿起枪射击猫。机率：3％。
4. 猫死了。机率：93％。

总概率：（3.202 * 10 ^-39）％。

C

该问题的大多数答案都误解了该问题，因为它正在杀死catUNIX系统上的进程。这是一个程序，该程序可能导致该问题特定的Felis Cattus物种的生物生命形态灭绝。

该示例在Windows上运行，但是通过替换iexplore -k为启动已安装的Web浏览器的命令，可以轻松地将其移植到大多数UNIX操作系统。

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

该程序假装向用户提供有关猫食的建议。

它将启动Internet Explorer，并将用户定向到pets stackexchange，其中列出了许多有关如何养猫的有用问题。然而，有，低（1/256）的机会，这将用户发送到烹饪stackexchange而不是列出的技巧如何准备含有巧克力，餐具是剧毒的猫。更糟糕的是，它将以信息亭模式（全屏）启动Internet Explorer，该模式将隐藏地址栏，并且对于那些不懂技术的用户来说很难摆脱。

这种聪明的诡计会诱使用户相信猫的巧克力是适合自己的饮食，从而诱使用户喂猫的巧克力，从而导致他们无意中杀死了它。

重击

据此，INT_MIN % -1可能会或可能不会未定义（什么???），因此可能会对使用c / c ++实现的任何语言造成麻烦。

#!/bin/bash

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

该cat如果家长将杀死早期bash进程崩溃，这可能会或可能不会发生。

在我的VM上，我得到以下输出：

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

（我不太了解这个问题的评分，但是无论如何，这里都可以）

计算$((2**63%-1))。崩溃总是发生在bash 4.2.25上，但似乎仅在某些3.x版本上挂起。更多的不确定性。我可以告诉您确切的概率，但是由于海森堡不确定性原理，我会掉进一个黑洞。或者其他的东西。因此，我认为我们可以肯定地说它们的机率约为42％。

C（序列点）

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

执行（或不执行）：

$ 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

情景和概率

假设运行此程序的人中有5％使用clang来编译C代码（相比之下，使用gcc时使用90％，使用其他C编译器时则为5％）：

得到“猫很好”的可能性。= .050
 收到“紧急通知：您的猫患有狂犬病”的可能性。= .950

 将其放下即可对“您的猫患有狂犬病”做出反应的概率= .040
 忽略通知的概率= .900
 将猫带到兽医处进行治疗的可能性= .060

 猫生存的总概率：.05 + .95 *（.90 + .06）= .962
 猫死的总概率：.95 * .04 = .038
 检查：猫存活或死亡的总概率：= 1.000

说明：

k = i +（++ i）访问并更改序列点之间的“ i”。概率不能由程序确定。这取决于用户选择的编译器。“未定义”不一定表示“随机”。

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

C

背景故事

我的妻子从家里继承了一只猫。^†不幸的是，我对动物过敏。这只猫已经过了它的鼎盛时期，甚至在我们得到它之前就应该被安乐死，但是由于它的感性价值，她无法摆脱它。我制定了一个计划来结束自己的痛苦。

我们本来打算放个长假，但她不想在兽医办公室上猫。她担心它会生病或受到虐待。我创建了一个自动猫喂食器，以便我们可以将其留在家中。我用C语言编写了微控制器的固件。其中包含的文件main与下面的代码相似。

但是，我的妻子也是一名程序员，并且知道我对这只猫的感受，因此她坚持要进行代码审查，然后才同意将其放在家里无人看管。她有一些担忧，包括：

• main 没有符合标准的签名（用于托管实施）
• main 不返回值
• tempTm用于未初始化，因为malloc被调用代替calloc
• 的返回值malloc不应该转换
• 微控制器时间可能不准确或滚动（类似于Y2K或Unix时间2038问题）
• 该elapsedTime变量可能不具有足够的范围

这令人信服，但她最终同意，这些问题并非出于各种原因（对于我们的航班已经来晚了，这并没有什么害处）。由于没有时间进行实时测试，因此她批准了代码，我们去了度假。几周后我们回来时，我的猫的痛苦结束了（尽管结果我现在有很多了）。

^{†完全虚拟的场景，无需担心。}

码

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

未定义的行为：

对于那些不想麻烦自己找到UB的人：

这段代码中肯定存在特定于本地的，未指定的和实现定义的行为，但是所有这些都应该正常工作。问题出在以下几行代码中：

struct tm * tempTm //... //... memcpy(&tempTm, localtime(&nowTime), sizeof(struct tm));
memcpy覆盖tempTM指针而不是它指向的对象，从而破坏了堆栈。除其他内容外，这还将覆盖elapsedTime和loopIterationsSinceFeed。这是我打印出值的示例运行：

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

杀死猫的可能性：

• 给定约束的执行环境和构建链，始终会发生未定义的行为。
• 同样，未定义的行为始终会阻止猫进给器按预期方式工作（或者允许其按预期方式“工作”）。
• 如果喂食器不起作用，则极有可能猫会死。这不是一只能自食其力的猫，我没能要求邻居照看它。

我估计那只猫死的概率为0.995。

重击

经典版

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

具有杀死范围内所有猫的优势。

请注意，该过程将立即停止，因此，通过单次调用pkill结束该过程的唯一方法是发送SIGKILL（9）。

因此：

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

量子版

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.

实验期间杀死猫的可能性：50％

C

请注意，这仅适用于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. 将随机数据写入文件并调用它（100％）
2. 随机数据恰好是天网的源代码（1x10 ^ -999999999999999999999999999999999999999999999999999999999999，aprox。）
3. 猫死于世界末日（99.999％）

总概率：1x10 ^ -999999999999999999999999999999999999999999999999999999999999999

C ++

您的猫既死又活，直到您好奇为止。然后，您意识到猫死了的可能性为0.5。

#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

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

杀死猫的概率：1/256（sleep(1)返回0，因此如果x它为零，它将被杀死。）

作为奖励，它可以杀死当前在系统上运行的所有猫。

如果您如此讨厌猫，我向您介绍：

猫C（重击）

echo "Hello World"|cat|cat|cat

基于以下事实：在《人类C（第一序列）》中，all的所有三只狗都死了，而three的三分之二都死了，我估计杀死一只猫的概率是5/6。

的JavaScript

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

执行：

• Chrome：结果"Cat is fine"
• Firefox：结果"Cat is dead"

说明：

15.5.4.9 String.prototype.locale比较（that）

以实现定义的方式比较两个字符串

引用Glenn Randers-Pehrson的观点，该程序无法确定该概率；这取决于用户对浏览器的选择。

int foo() {}

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

读取应该返回值的函数值会导致未定义的行为。现在，很明显，^{[需要引用]}：“每次达到不确定的行为，上帝就会杀死一只小猫。” 由此得出结论：

• 您达到不确定行为的机率-100％
• 上帝杀了你的小猫的概率-1/200000000 看看为什么
• 所以概率是0.0000005％

可以轻松地循环扩展以消灭世界上所有的猫。

Java（垃圾回收）

尽管代码可以调用System.gc（），但不能确保垃圾收集器将收集所有未使用的对象。因此，对于以下代码，无法确定猫是否会被杀死。

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

无法计算概率。

请注意，如果在sysout之后和System.exit（0）之前的GC线程中有上下文切换，则猫仍然有可能“复活”，但我不愿覆盖它以使概念更简单。

有人想过要真正杀死（a）cat吗？

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

cat死亡几率

为了概率...我想我们需要区分一些情况：

1. Windows用户：可能无法执行。cat即将死去的机会s非常低，可以安全地假定为零。如果安装了Cygwin，他将被视为Unix用户。
2. 没有root特权的Unix用户：杀死catwill失败。
3. 以root特权运行的Unix用户：虽然每个调用只会cat以1/6的机会杀死s，但他很可能会重复执行该操作，直到发生意外情况为止。在不失一般性的前提下，我cat想肯定会死的。

总体概率取决于用户的混合方式，并且难以确定。但是我们可以肯定地说：Windows是小猫的安全场所。

测试是否遵守规则

出示答案时，不会对动物造成伤害。

这没有杀死动物，答案得到了美国人道主义协会的认可。

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

清楚地证明那cat不是动物（只要file不知道任何类型的隐藏文件类型继承）。

C

如果猫的名字太长，它就会死。gets导致猫死亡以及其他问题。

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

哈斯克尔

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

在这里，我们适用unsafePerformIO于具有可观察到的副作用的动作。这始终是不确定的行为，至少效果的顺序也是如此。因此，该程序将首先在尝试评估时崩溃undefined（具有讽刺意味的是，它不是未定义的行为：它绝不能产生允许该程序继续进行其他操作的值），或者实际上会导致严重的国际化。副作用。在这种情况下，生存机会仅为0.001％。

因此，杀死猫的概率为49.9995％。

ue

由于问题允许一种语言，只要其效果相似，就不会有不确定的行为，因此我选择Thue是因为它的不确定性，即当有多个规则可应用于当前规则时选择执行哪个规则州。

该程序将被送入微波炉的控制器中，在其中是我的猫。微波炉的门是关闭的，并用一条拉链结扎好。程序的输出将决定微波炉是否开始对猫进行微波处理。

• 如果输出为0，我们将开始实验长期暴露微波对活的哺乳动物（目前尚未充分研究）的影响。
• 如果输出为1，我们将对猫刚刚失去9条生命之一并将其放出这一事实感到满意。

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

杀死猫的概率取决于解释器的实现方式，但可以说是50％。那么，猫死的概率为0.5。

爪哇

根据规范 java.util.Date将具有不确定的行为。因此，请尝试您的运气：

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