You probably want to use `SetPrecision`.  For example:

    x = N[Pi] (* 3.14159 *)
    x // Precision (* MachinePrecision *)

    y = SetPrecision[x, 3] (* 3.14 *)
    y // Precision (* 3. *)

    z = SetPrecision[Pi, 5] (* 3.1416 *)
    z // Precision (* 5. *)

    v = y * z (* 9.87 *)
    v // Precision (* 2.9958 *)

    w = y + z (* 6.28 *)
    w // Precision (* 3.29671 *)

So we can see that `SetPrecision` sets the number of significant digits to the desired number.  This precision will be used when printing to set the number of digits, and will also be used when computing with other arbitrary-precision numbers to set the precision of the result.

However, mixing machine-precision and arbitrary-precision numbers does not work, as the result will be converted back to machine precision:

    Precision[x*y] (* MachinePrecision *)

(This does not affect using arbitrary-precision numbers with exact numbers like `4`, `134/267`, `Pi`, or `E`.)  We can get around this restriction by converting any machine-precision numbers to exact form, or setting their precision manually:

    Precision[Rationalize[x, 0]*y] (* 3. *)
    Precision[SetPrecision[x, $MachinePrecision]*y] (* 3. *)

Note that you must use `$MachinePrecision`, not `MachinePrecision`.  The first one will evaluate to a number (`15.9546` on my 64-bit machine, equal to 53 bits: the size of the significand of an [IEEE double](http://en.wikipedia.org/wiki/IEEE_floating_point#Basic_and_interchange_formats)) and return an arbitrary-precision number with precision equal to a machine-precision number, while the second one is the symbol that Mathematica uses to represent machine-precision numbers, so the number will stay machine-precision.

Note that Mathematica keeps more digits internally than are displayed, for example:

    y (* 3.14 *)
    y // FullForm (* 3.14159265358979311599796346854418516159`3. *)

**This is a good thing.**  It prevents rounding errors, so that you know your 3-digit-precision number actually is accurate to three digits.  For a simple example, convert the number $1.004$ to three digit precision, and double it.  Doing this naively you get $1.00\times 2=2.00$.  However, the answer should be $2.01$, closer to the actual full-precision value of $2.008$.

However, if you want to retain this erroneous behavior you will have to use a special function to round the numbers.  Try this one:

    round[n_] := SetPrecision[Round[n, 10^Floor[-Precision[n] + Log10[Abs[n]]]], 
     Precision[n]]
    y (* 3.14 *)
    round[y] (* 3.14 *)
    % // FullForm (* 3.142`3. *)

Note that in this case it gives you one extra digit.  This is due to the definition of precision in Mathematica:

> With absolute uncertainty `dx`, `Precision[x]` is `-Log[10,dx/x]`.

This is incompatible with the typical definition of precision, which has discontinuous behavior (e.g. $1.00$ and $9.99$ have 3 digits of precision, but $10.00$ has 4).

To use the typical definition you'll have to round manually:

    round[n_, d_] := 
     SetPrecision[Round[n, 10^(Ceiling[Log10[Abs[n]]] - d)], d]
    a = round[1, 3] (* 1.00 *)
    a // FullForm (* 1.`3. *)
    b = round[0.999, 3] (* 0.999 *)
    b // FullForm (* 0.999`3. *)

To avoid Mathematica's default precision-handling behavior you will also have to compute the precision and re-round for every operation, or at least write custom functions for every operation.

**This is not a good idea.**  You will then be subject to errors as I describe above, and the whole point of Mathematica is that you can ignore details like this.  In summary, just use `SetPrecision` and your calculations will automagically work out as accurately as they can.