Memory problem? dtostr() and strcat()
Your sketch is running on borrowed memory.
Every time the loop function runs, the new text is concatenated with strcat() and the buffer msg_out is never reset.
The first time 12 bytes are used, the second time 23 bytes, the third time 34, and so on.

The solution in the answer by @VE7JRO will fix that, but I prefer not to use dtostrf() and transmit binary data.

I see a few other problems as well:


Why do you want to transmit readable ASCII text? Use binary data. 
Either float numbers or integers. For example an integer in 1/100 degrees.
The RadioHead library uses a lot of memory. You can not use an other 
library that uses also a lot of memory.
The value of '5' for dtostrf is the minimal width, 
so you better make those arrays for example 20 bytes.
I prefer to put those arrays temporarily on the stack.
The DHT11 is not accurate. If you upgrade to a better sensor with I2C,
then you need more libraries (the Wire library and a sensor library),
and you might run out of sram memory.
When using the RadioHead library in default mode, it uses three
pins (rxPin=11, txPin=12, pttPin=10). You better add a comment
section to your sketch to explain that you should not use those pins. 
You have already a
conflict at pin 10 for the DHT sensor and the pttPin.




The old and no longer supported VirtualWire library has some bugs, but it uses less memory than the RadioHead library. The RadioHead library is not optimized for Arduino boards like the Uno, Nano, Leonardo, and others. It even requires to #include &lt;SPI.h&gt; because that is often used with transceivers, even if the SPI bus is not used in RH_ASK mode (thanks to @VE7JRO for explaining this in the comment below).



The easiest way to transmit more than one value is with an array.

float myData[2];
myData[0] = 23.456;
myData[1] = 68.0;
rf_driver.send((uint8_t *)myData, sizeof(myData));


The sizeof() is not a real function, it tells the compiler to fill in the size of that variable. Since a float is 4 bytes, you may also fill in the number 8 for the second parameter.

There are a number of solutions for the receiver. I like to use a pointer to the buffer, but perhaps it is easier to copy them to variables with memcpy().

float myData[2];
if (driver.recv(buf, &amp;buflen)) {
  if (buflen == sizeof(myData) {  // extra check
    memcpy((uint_8 *)myData, buf, sizeof(myData));
    Serial.println(myData[0]);
    Serial.println(myData[1]);
  }
}


When the receiver is also an Arduino board, then there should be no problem. When the receiver is something else, you might have to check if the byte-order is the same. The float variable of a Arduino is 100% IEEE compatible, but sometimes it is easier to use only integers.

The most common way is to use a struct. A struct is a package that can hold all sorts of data (integers, bytes, arrays, and so on). The receiver and the sender should have exactly the same definition for the struct of course.