Q:

Why is my class variable changing its value between methods?

I am trying to load a bitmap animation to the screen. I have a float variable holdTime that is specified to hold the "holdtime" value for the animation. In my constructor I set the holdtimevariable to 0.1f but when I try to access the method in the class that is using the holdTime variable, the value of holdTime has changed to -107374176f. So somewhere between my constructor call and the method call the value has changed from 0.1f to -107374176f. 
To make things a little bit more clearer let me show you some code: 
Here is the header file for the Game class, this is where I call the constructor of the Animation class that has the holdTime variable.
  #pragma once

#include "Graphics.h"
#include "Surface.h"
#include "Animation.h"
#include "FrameTimer.h"

class Game
{
public:
    Game( class MainWindow& wnd );
    void Go();
private:
    void UpdateModel();

private:
    MainWindow& wnd;
    FrameTimer ft;
    Surface surf = Surface("Test32x48.bmp");
    Animation testAnimation = Animation(0, 0, 32, 48, 4, surf, 0.1f);
};

You see that I have this testAnimation at the bottom of the class. The last argument in the constructor call is the value that is ought be in holdTime.
This is how my Animation header file looks like: 
#include "Surface.h"
#include "Graphics.h"
#include <vector>

class Animation {
public:
    Animation(int x, int y, int width, int height, int count, const Surface& sprite, float holdtime, Color chroma = Colors::Magenta);
    void Update(float dt);
private:
    void Advance();
private:
    std::vector<RectI> frames;
    int iCurFrame = 0;
    float holdTime = 0;
    float curFrameTime = 0.0f;
};

And this is the Animation Cpp file: 
 #include "Animation.h"

Animation::Animation(int x, int y, int width, int height, int count,
    const Surface& sprite, float holdtime, Color chroma)
    :
    sprite(sprite),
    holdTime(holdTime),
    chroma(chroma)
{
    for (int i = 0; i < count; i++)
    {
        frames.emplace_back(x + i * width, x + (i + 1) * width,y, y + height);
    }
}

void Animation::Update(float dt)
{
    curFrameTime += dt;
    while(curFrameTime >= holdTime) {
        Advance();
        curFrameTime -= holdTime;
    }
}

void Animation::Advance()
{
    if (++iCurFrame >= frames.size()) {
        iCurFrame = 0;
    }

}

There is only one method that is making use of holdTime and that is the method Update(float dt). 
If we go back to the Game class and look at the Game.cpp file:
#include "MainWindow.h"
#include "Game.h"

Game::Game( MainWindow& wnd )
    :
    wnd( wnd ),
    gfx( wnd )
{
}

void Game::Go()
{
    UpdateModel();
}

void Game::UpdateModel()
{
    testAnimation.Update(ft.Mark());
}

In the Method Go() we call the method UpdateModel() which in turn is calling the Update() method in the animation class. This means that the first method to be executed in the Animation class after the constructor call is the update() method. When I debug the program I can see that the value of holdtime has changed between the constructor call and the Update() method call. But I don't know how since it I am not modifying the value somewhere else. It also seemes that the new value of holdTime is garbage value. 
It became a lot of code in this question and it looks a bit messy and even though I lack the skills of writing a good Title I hope I made you somewhat clear what my problem is.
Thanks!
Update:
Here is the code for the FrameTimer class since the value returned from one of its methods is passed in into the Update() method:
FrameTimer.H:
#pragma once
#include <chrono>

class FrameTimer
{
public:
    FrameTimer();
    float Mark();
private:
    std::chrono::steady_clock::time_point last;
};

FrameTimer.cpp:
#include "FrameTimer.h"

using namespace std::chrono;

FrameTimer::FrameTimer()
{
    last = steady_clock::now();
}

float FrameTimer::Mark()
{
    const auto old = last;
    last = steady_clock::now();
    const duration<float> frameTime = last - old;
    return frameTime.count();
}

Edit:
main.cpp:
    int WINAPI wWinMain( HINSTANCE hInst,HINSTANCE,LPWSTR pArgs,INT )
    {
        MainWindow wnd( hInst,pArgs );      
            Game game( wnd );
            while( wnd.ProcessMessage() )
            {
                game.Go();
            }
    }

As you can see the game.Go() method is the first method that is called in main.

A:

Your Animation constructor is at fault:
Animation::Animation(int x, int y, int width, int height, int count,
    const Surface& sprite, float holdtime, Color chroma)
    :
    sprite(sprite),
    holdTime(holdTime),
    chroma(chroma)
{
    for (int i = 0; i < count; i++)
    {
        frames.emplace_back(x + i * width, x + (i + 1) * width,y, y + height);
    }
}

Here you attempt to initialise the member holdTime from the parameter holdTime.
Except, there is no parameter holdTime. There is only the parameter holdtime.
Hence instead you are actually initialising the member holdTime from itself (the next nearest "match" for that name), so it only retains its original, unspecified value (and in fact, reading an uninitialised variable results in your program having undefined behaviour).
So, you see, your member variable doesn't "change" at all — you never set it correctly. You'd have known that had you put some diagnostic output inside that constructor to examine the value and see whether it's what you thought it should be. None of the rest of the code was relevant or necessary.
A properly-configured compiler should have warned you about this.

