Kona, 10 Bytes

{y+x*1+!z}

Try it out!

Wolfram Language (Mathematica), 13 bytes

Range@#3#+#2&

Try it online!

brainfuck, 43, 30 bytes

,>,>,[-<<[-<+>>+<]<[->+<]>>.>]

Try it online!

Takes M, C, V in ascii ordinals, some if not most implementations use unicode ordinals.

Doesn't work in floats.

Thanks to @WeirdGlyphs for -13 bytes. Also, this user gave me the explanation for the code.

Explanation:

,>,>,                            take (M C V)
     [                           while V != 0:
      -                              V minus 1
       <<[                           while M != 0:
          -<+>>+<]                       M minus 1; temp plus 1; C plus 1
                  <[->+<]            M = temp; temp = 0
                         >>.>]       print(C)

Raku (Perl 6) (rakudo), 45 bytes

my ($m,$c,$p)=@*ARGS;for 1..$p {say $m*$_+$c}

Attempt This Online!

Uiua, 5 bytes

+×+1⇡

Try it: Uiua pad

• Add
  • the product of
    • the range 1 to V
    • and M
  • and C

Ruby, 25 bytes

-2 bytes thanks to G B.

->m,c,v{(1..v).map{c+=m}}

Attempt This Online!

Tcl, 64 bytes

proc C {m c v} {time {lappend L [expr $m*[incr i]+$c]} $v
set L}

Try it online!

Zsh +coreutils, 24 bytes

echo $1\*{1..$3}+$2\;|bc

Try it online!

There's also a short solution using jot and setopt force_float but that would be unoriginal.

Japt, 4 bytes

õ!ìV

Try it here

Python, 40 39 35 bytes

lambda M,C,V:[C:=C+A for A in[M]*V]

-1 byte by tsh
-4 bytes by Albert.Lang

Forth (gforth), 35 bytes

: a 0 DO 2DUP OVER I * + + . LOOP ;

Try it online!

Just works with integers, not with floats. Modifies global integer stack state.

Charcoal, 9 bytes

Ｉ⁺×…·¹ＮＮＮ

Try it online! Link is to verbose version of code. Takes input in the order V, M, C. Explanation: Forms a range from 1 to V, vectorised multiplies it by M and vectorised adds C.

6 bytes by requiring input in JSON format:

Ｉ⁺×⊕…Ｎ

Try it online! Takes input in the order V, M, C. Explanation: Forms a range from 0 to V-1, increments it, then vectorised multiplies it by M and vectorised adds C.

05AB1E, 3 2 bytes

Lβ

Two loose inputs in the order and format \$V\$ and \$[M,C]\$.

Try it online or verify all test cases.

Explanation:

L   # Push a list in the range [1, first (implicit) input V]
 β  # Convert the second (implicit) input-pair [M,C] from a base-v list to a
    # base-10 integer for each v in the [1,V]-ranged list
    # (after which this list is output implicitly)

Excel 365, 35 bytes

Input M, C, V into A1:C1.

In any other cell, write the formula:

=MAKEARRAY(C1,,LAMBDA(x,y,x*A1+B1))

PowerShell, 36 bytes

iex('1..{2}|%{{{0}*$_+{1}}}'-f$args)

Try it online!

The obvious solution would be something like for($i=1;$i-le$args[2];$i++){$args[0]*$i+$args[1]} for a whopping 50 bytes, mainly due to the $args elements.
Using iex (an alias for Invoke-Expression, which interprets a string as PowerShell), and the format operator -f, allows to golf 14 bytes from that.
Slightly ungolfed:
'1..{2} | % {{ {0} * $_ + {1} }}' -f $args
$args is an array which contains the three input values; they will be inserted into the string at {0}, {1}, {2}, respectively (the double {{ and }} escape the curly brackets required for the loop).
So with 2, 0, 5 as input, that would create the string
1..5 | % { 2 * $_ + 0 }
% is an alias for ForEach-Object, and $_ is the loop variable.
iex will then run this string as PowerShell.
Output is implicit.

Desmos, 19 bytes

f(m,c,v)=[1...v]m+c

Try It On Desmos!

What better way to solve a "graphing" calculator problem... than to literally use a graphing calculator!

Nekomata, 3 bytes

R*+

Attempt This Online!

Takes input in the order V, M, C.

R*+
R       [1,...,V]
 *      Times M
  +     Add C

JavaScript (Node.js), 32 bytes

m=>c=>g=v=>v?[c+=m,...g(v-1)]:[]

Try it online!

Octave, 17 bytes

@(m,c,v)(1:v)*m+c

Try it online!

Basically the same code as Eonema posted in the answer in R.

R, 15 bytes

\(m,c,v)m*1:v+c

Try it online! (Note- TIO doesn't yet support \ for function)

Nim, 57 bytes

proc f(m,c,v:float)=
  if v>0.0:f(m,c,v-1.0);echo (m*v)+c

Attempt This Online!

Bash + common utilities, 27

jot -- $3 `bc<<<$2+$1` - $1

Try it online!

AWK, 30 bytes

{for(;i++<$3;)printf$1*i+$2FS}

Attempt This Online!

{for(;i++<$3;) # increment to V
printf         # print Y
$1*i+$2        # MX+C
FS}            # space between numbers

JavaScript (ES6), 33 bytes

Expects (m)(c)(v) and returns an array of floats.

m=>c=>g=v=>v?[...g(v-1),m*v+c]:[]

Try it online!

Commented

m =>             // 1st function taking m
c =>             // 2nd function taking c
g = v =>         // g = recursive function taking v
v ?              // if v is not 0:
  [              //   update the output array:
    ...g(v - 1), //     append the result of a recursive call with v-1
    m * v + c    //     followed by the current value m*v+c
  ]              //   end of array
:                // else:
  []             //   stop the recursion

Haskell + hgl, 19 bytes

m#c=ft[m+c,2*m+c..]

Attempt This Online!

Ungolfed:

f m c v = take v [m+c, 2*m+c]

APL+WIN, 6 bytes

Prompts for input of v followed by m and then c

⎕+⎕×⍳⎕

Try it online! Thanks to Dyalog Classic

C# (Visual C# Interactive Compiler) with /u:System.Linq.Enumerable flag, 36 bytes

(m,c,v)=>Range(1,v).Select(i=>m*i+c)

Try it online.

Explanation:

(m,c,v)=>           // Method with two double and one integer inputs
                    // and IEnumerable<double> return-type
  Range(1,v)        //  Create an IEnumerable in the range [1,v]
  .Select(i=>       //  Map each value `i` to:
             m*i+c) //   Multiply `m` by `i` and add `c`

Vyxal 3, 3 bytes

ɾ×+

Vyxal It Online!

Input in the form V, M, C as separate args

APL (Dyalog 20.0), 5 bytes

Anonymous tacit infix function, taking V as left argument and [M,C] as right argument.

⍪⍤⍳⍛⊥

Try it online! (emulation due to old TIO version)

…⍛⊥ evaluate in mixed-base, but first pre-process the left argument as follows:

 …⍤⍳ expanding to the indices 1…V, and then:

  ⍪ transform into a column vector (matches up the entire [M,C] with each of 1…V)