Perlin Noise Generator
Here are some things that may help you improve your code.

Strive for portable code

Several of the features of this code are either platform-specific or compiler-specific or both.  Specifically, #include &lt;conio.h&gt;, and #include "stdafx.h" both non-standard.  Further, neither are actually used so I would strongly recommend omitting them.

Prefer to avoid using new and delete directly

In modern C++, it's usually better to avoid explicit calls to new and delete.  In particular, it seems that the goal of this program is to create the perlinnoise matrix.  It is not clear whether you're intending to also use the noise array or if it's just a byproduct of the production of the perlinnoise array.   In any case, use of raw new and delete tends to lead to the problem mentioned in the next suggestion.

Consider using a better random number generator

You are currently using 

noise[i][j] = (float)rand() / RAND_MAX;


However, that's the old C way to do things.  better solution, if your compiler and library supports it, would be to use the C++11 `std::uniform_real_distribution.  It looks complex, but it's actually pretty easy to use, as I'll demonstrate below.

Don't leak memory

If you use new and delete directly, you must take care to make sure they match in every instance.  This is quite easy to get wrong, and in fact, this code gets it wrong.  In particular, the perlin_noise routine leaks memory.  Track how long it takes you to find and fix the problem, and then compare it to the following suggestion.

Use objects

C++ is an object-oriented language and accomodating and encouraging that style of design is one of the key benefits of using C++.  For that reason, and because it makes your program cleaner, easier to maintain, easier to re-use and less prone to error, I'd highly recommend using objects for this program.  

Use the Standard Template Library

There is a lot of functionality already available to you if you use the Standard Template Library (STL).  To illustrate this and a number of the previous points, here is a rewrite of your white_noise routine as an object.  First, we need a way to initialize it with random values, and then a way to address individual noise values by index.  This is easily done by deriving a WhiteNoise object from a std::valarray.

struct WhiteNoise : public std::valarray&lt;double&gt;
{
    WhiteNoise(int w, int h) :
        std::valarray&lt;double&gt;(w*h), 
        width{w},
        height{h}
    {
        std::mt19937 gen;
        std::uniform_real_distribution&lt;double&gt; dis;
        for (auto &amp;value : *this) {
            value = dis(gen);
        }
    }
    int width;
    int height;
};


Note that there is no explicit call to new or delete and that the width and height are embedded into the object rather than separate quantities.  If you create a similar PerlinNoise object, the main function could look like this:

int main()
{
    const int w = 400;
    const int h = 400;

    WhiteNoise wn(w,h);
    PerlinNoise pn(wn, 8, 0.7);

    // Create a bitmap just so that we have something to look at.
    makePGM(pn, "perlin.pgm");
}


The result: no memory leak and a much shorter, cleaner program (also faster in my testing, but you should test it on your machine).  The makePGM is just a function I wrote to create a bitmap image to visualize the result.