[Question]
  [
This is a cake:
```
_========_
|        |
+________+
|        |
+________+
|        |
+________+
```
It is 8 wide, 3 tall, and 1 deep.
You must write a program that makes a cake from 3 inputs. The first input controls how many underscores there are in the middle and `=`s on the top. Here's the first cake with a width of 10 instead of 8:
```
_==========_
|          |
+__________+
|          |
+__________+
|          |
+__________+
```
The second input controls how tall the cake is. Here's the second cake with a height of 4 instead of 3:
```
_==========_
|          |
+__________+
|          |
+__________+
|          |
+__________+
|          |
+__________+
```
Note the repetition of the layers.
The third input controls how deep it is. That just how many `| |`s to include on the top. Here's the third cake with a depth of 2 instead of 1:
```
_==========_
|          |
|          |
+__________+
|          |
+__________+
|          |
+__________+
|          |
+__________+
```
You can print trailing whitespace. Test cases:
Input: `3`, `3`, `3`
Output:
```
_===_
|   |
|   |
|   |
+___+
|   |
+___+
|   |
+___+
```
(I hope I never get this cake)
Input: `3`, `2`, `1`
Output: 
```
_===_
|   |
+___+
|   |
+___+
```
Input: `5`, `5`, `5`
Output:
```
_=====_
|     |
|     |
|     |
|     |
|     |
+_____+
|     |
+_____+
|     |
+_____+
|     |
+_____+
|     |
+_____+
```
  
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~25~~, 20 bytes
```
2é_Àé=ÙÒ|èÙÒ+È_ÀäkÀÄ
```
[Try it online!](https://tio.run/##K/v/3@jwyvjDDYdX2h6eeXhSzeEVIEr7cAdIbEk2kGj5//@/5X@T/0YA "V – Try It Online")
Hexdump:
```
00000000: 32e9 5fc0 e93d d9d2 7ce8 d9d2 2bc8 5fc0  2._..=..|...+._.
00000010: e46b c0c4                                .k..
```
Thanks to *@nmjmcman101* for saving three bytes, and reminding me of an old operator that saved another two bytes.
Explanation:
`a`, `b`, and `c` are the three arguments.
```
2é_                   " Insert two '_' characters
   Àé=                " Insert 'a' '=' characters between them
      Ù               " Duplicate this line
       Ò|             " Replace this whole line with '|'s
         è            " *Hollow* this line (replace all the middle characters with spaces)
          Ù           " Duplicate this line
           Ò+         " Replace this whole line with '+'s
             È_       " *Hollow* this line again, but use '_' instead of spaces
               Àäk    " Make 'b' copies of this line and the line above it
                  ÀÄ  " Make 'c' copies of this line
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~34~~ 26 bytes
```
Ｎγ←×γ_↑+↑Ｎ_×γ=‖ＢＯγＦ⁻Ｎ¹Ｃ⁰±²
```
[Try it online!](https://tio.run/nexus/charcoal#VY0xD4IwEIV3fsWF6RpLQnGDuKiLA4SYOBtJam2CLSkF9dfXg6mM9733vgsXM0y@md6ddNixKmmdNh7L28Ah3aVbEOVXrV6eKvelEjsU3Sc7/LDtpxEFB8U45ASP9ouKA5H0sIxqO0vsOJRn@zHbfJU@rQOstSFL7CebYAzWFzmHRqqHl1gwVoUgkn1ShGwO2dj/AQ "Charcoal – TIO Nexus") Link is to verbose version of code. Takes parameters in the order width, depth, height. Explanation:
```
Ｎγ          Input the width.
←×γ_        Print a set of _s that go at the bottom of each layer.
↑+          Print one of the +s that go on the left.
↑Ｎ          Input the depth and print that many left |s.
_           Print the top left _.
×γ=         Print the =s along the top.
‖ＢＯγ        Copy the left column to the right.
Ｆ           Repeat:
 ⁻ ¹         One time fewer than:
  Ｎ           Input of the height:
    Ｃ⁰±²        Copy the whole cake up 2 characters.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~33~~ 31 bytes
```
'_'=¹×«Ć,'|¹úRĆ³G=}²F='+'_¹×«Ć,
```
[Try it online!](https://tio.run/nexus/05ab1e#@68er257aOfh6YdWH2nTUa8BMncFHWk7tNndtvbQJjdbdW31eLj0//@mXEAIAA "05AB1E – TIO Nexus")
## Explanation
```
'_'=¹×«Ć,'|¹úRĆ³G=}²F='+'_¹×«Ć,   Full program
'_                                Push literal '_'
  '=¹×                            Push '=' w times
      «Ć,                         Concat, enclose and print
         '|                       Push literal '|'
           ¹ú                     Pad with w spaces in front
             RĆ                   Reverse and ecnlose
               ³G }               d - 1 times do:
                 =                Print without consuming
                   ²F             h times do:
                     =            Print without consuming
                      '+          Push literal '+'
                        '_¹×      Push '_' w times
                            «Ć,   Concat, enclose and print
```
[Answer]
## Mathematica, 167 bytes
```
c=Column;r=Row;t=Table;f=Flatten;c[c/@{r/@f[{{{"_",r@t["=",#],"_"}},t[{"|",r@t[" ",#],"|"},#3-1]},1],c/@f[{t[{r@{"|",r@t[" ",#],"|"},r@{"+",r@t["_",#],"+"}},#2]},1]}]&
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~30~~ 29 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
-1 byte switching from an addition to an XOR to translate between outer and inner columns, allowing for a 5 character lookup rather than having two `_` entries.
```
ṬṚ;⁹RḤṬḤ¤Wµ^9ẋ⁵;@;µZị“_+= |”Y
```
Full program taking three program arguments of `depth`, `height`, `width` and printing the cake.
**[Try it online!](https://tio.run/nexus/jelly#AUAAv///4bms4bmaO@KBuVLhuKThuazhuKTCpFfCtSsz4bqL4oG1O0A7wrVa4buL4oCcXysgPV984oCdWf///zL/NP84 "Jelly – TIO Nexus")**
### How?
```
ṬṚ;⁹RḤṬḤ¤Wµ^9ẋ⁵;@;µZị“_+= |”Y - Main link: depth, height (width is a program argument)
Ṭ                             - untruth   [0,0,0,...1] such that the length is the depth
 Ṛ                            - reverse   [1,0,0,...0]
        ¤                     - nilad followed by link(s) as a nilad:
   ⁹                          -   link's right argument, height
    R                         -   range   [1,2,3,...,height]
     Ḥ                        -   double  [2,4,6,...,2*height]
      Ṭ                       -   untruth [0,1,0,1,0,1,...,0,1] (length double height)
       Ḥ                      -   double  [0,2,0,2,0,2,...,0,2]
  ;                           - concatenate  [1,0,0,...,0,0,2,0,2,0,2,...,0,2]
                              -     ...this is the form of a column of cake!
         W                    - wrap in a list
          µ                   - monadic chain separation, call that c
           ^9                 - bitwise XOR c with 9 [8,9,9,...,9,9,11,9,11,9,11,...,9,11]
              ⁵               - program's 3rd argument, width
             ẋ                - repeat the augmented c width times
               ;@             - concatenate with a copy of c
                 ;            - concatenate a copy of c
                  µ           - monadic chain separation call that sideways cake
                   Z          - transpose the sideways cake to put it the right way up
                     “_+= |”  - literal ['_','+','=',' ','|'] (cake decoration)
                    ị         - index into (1 based and modular, so 8,9, and 11 are, mod 5,
                                            3, 4, and 1 yielding '=', ' ', and '_')
                            Y - join with new lines
                              - implicit print
```
[Answer]
# PHP>=7.1, 104 Bytes
```
for([,$w,$h,$t]=$argv;$i<2*$h+$t;)echo str_pad($e="_|+"[$b=$i++<$t?$i>1:1+$_++%2],$w+1,"= _"[$b])."$e
";
```
[Online Version](http://sandbox.onlinephpfunctions.com/code/983af2a1ab6ca8009ae723ab6b93c95c2702cd9e)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 62 bytes
```
->w,h,d{l="|#{' '*w}|
";"_#{?=*w}_
"+l*~-d+(l+"+#{?_*w}+
")*h}
```
[Try it online!](https://tio.run/nexus/ruby#S7ON@a9rV66ToZNSnWOrVKNcra6grlVeW8OlZK0Ur1xtbwvkxHMpaedo1emmaGvkaCtpA0XjgaLaXEqaWhm1/wtKS4oV0qJNdIAw9j8A "Ruby – TIO Nexus")
[Answer]
# [Haskell](https://haskell.org), 87 bytes
```
f w t d=["_=| +_\n"!!j|i<-0:([2..d]>>[2])++([1..t]>>[2,4]),j<-i:([1..w]>>[i+1])++[i,6]]
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~51~~ 47 bytes
```
"_{ç'=}_"+WçA="
|{ç}|" +(B="
+{ç'_}+" +(´V çA+B
```
[Try it online!](https://tio.run/nexus/japt#@68UX314ubptbbySdvjh5Y62Slw1QIHaGiUFbQ0nIE8bJB1fqw3iH9oSpgBUo@30/7@ljoKxjoIhAA "Japt – TIO Nexus")
Input is taken in the order width, height, depth.
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 108 bytes
```
?sdstsw95P61sc[lwsf[lcPlf1-dsf0<a]dsax]dsbx[_]p[[124P32sclbx[|]pld1-dsd0<j]dsjx43P95sclbx[+]plt1-dst0<h]dshx
```
[Try it online!](https://tio.run/##JcpBCsMgEIXhq2RfAppoICD0Cu4HKXamIkHawAhxkWt3bSd08xbv@wl7vzNx5WO1ftGMUA5OUNCXpEfipFwMxLHJPBs8wg6gJ@PnibHIcYa90BWScps0WzOzX@0fb4L1wqpcFsytdzPYYfm@PyNGzK8f "dc – Try It Online")
[Answer]
# [Röda](https://github.com/fergusq/roda), 65 bytes
```
a,b,c{d=" "*a;[`_${"="*a}_
`,`|$d|
`*(c-1),`|$d|
+${"_"*a}+
`*b]}
```
[Try it online!](https://tio.run/##K8pPSfyfFvM/USdJJ7k6xVZJQUkr0To6IV6lWskWyKyN50rQSahRSanhStDSSNY11ITytIEK4kEKtIESSbG1/3MTM/OquRQSbaMtdIx1DIEYAo2AbFMQjAVKamjWpCnE6wAhV@1/AA "Röda – Try It Online")
[Answer]
# [Java 7](http://openjdk.java.net/), ~~169~~ ~~164~~ 158 bytes
```
String f(int...a){String s="_",t="|",u="+";for(;a[0]-->0;s+="=",t+=" ")u+="_";s=s+"_";t="\n"+t+"|";u=t+"\n"+u+"+";for(;a[2]-->1;)s+=t;for(;a[1]-->0;)s+=u;return s;}
```
[Try it online!](https://tio.run/nexus/java-openjdk#fY7BasMwDIbPyVMInWzsmqZjJ@O9wU49dqV4XVICiRNsuWWkefbMbrpr0UHi06cfjfG7a89w7mwI8GlbN5VlMa4wkKXUrkP7A31asT351l0OR7D@EvhUFkW@gB4MuPr2OGdcJ7z/DVT3aoikxnRCnWO9atibTMVfGztZvTTeZapszMv6DjQsbZVSlk9PEgyeUJLBO8poUKBuBs@0PWyPm83HVgdh0CQhNUAeRdYf8PTlUGd8z0M0JKJAkednwC4HVJonmf5ZtYZmFrWvKXoHQc/LvPwB)
Ungolfed: 
```
String f(int...a)                    // saves two bytes over int a, int b, int c
{
    String s="_", t="|", u="+";      // set up the start of each row
    for(; a[0]-->0; s+="=", t+=" ")  // Uses the goes-to operator to fill the row
        u+="_";                      
    s += "_\n";                      // adds the end of each row
    t += "|\n";              
    u = t + u + "+\n";               // and combining t into u
    for(; a[2]-->1; )                // add the top of the cake
        s += t;
    for(; a[1]-->0; )                // add the rest of the cake
        s += u;
    return s;
}
```
[Answer]
# Windows Batch, ~~211 180~~ 163 bytes
Golfed a total of ***48 bytes*** thanks to @Neil!
```
@for /l %%p in (1,1,%1)do @call set w= %%w%%
@echo _%w: ==%_
@for /l %%p in (2,1,%3)do @echo ^|%w%^|
@for /l %%p in (1,1,%2)do @echo ^|%w%^|&echo +%w: =_%+
@set w=
```
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 25 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
e =*¼_Oe↕¼|.⌡Qe╔*¼+.H«{Q;
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=ZSUyMCUzRColQkNfT2UldTIxOTUlQkMlN0MuJXUyMzIxUWUldTI1NTQqJUJDKy5IJUFCJTdCUSUzQg__,inputs=OCUwQTElMEEz)
Expects the input as width, depth, then height.
[Answer]
# Python 2, ~~124~~ ~~122~~ ~~120~~ ~~105~~ 92 bytes
```
w,t,d=input()
a="\n|"+w*" "+"|"
print"_"+w*"="+"_"+(d-1)*a+t*(a+"\n+"+w*"_"+"+")
```
-15 bytes by using STDIN instead of program arguments
-13 bytes by switching to Python 2 (for `input()`ing integers and `print` statement)
-12 bytes from Caird Coinheringaahing
[Try it online!](https://tio.run/##K6gsycjPM/r/v1ynRCfFNjOvoLREQ5Mr0VYpJq9GSbtcS0lBSVupRomroCgzr0RBKR4sZgsUA7I0UnQNNbUStUu0NBK1gRq0wZJACSDU/P/fWMdIxxBCAgA "Python 2 – Try It Online")
# Python 3, ~~124~~ ~~122~~ ~~120~~ 105 bytes
```
w,t,d=[int(input())for n in(1,2,3)]
a="\n|"+w*" "+"|"
print("_"+w*"="+"_"+(d-1)*a+t*(a+"\n+"+w*"_"+"+"))
```
[Try it online!](https://tio.run/nexus/python3#HYvBCoMwEETv@Yqwp2w2FaLnfImVEpBKDl0lhorgv2@3MpeZ9xgpn22tze7nbo7QwpzGws3p7HJdviNP@F6rZVvYxdCHASeTEzz5Ajo8WCC4wGz1f4LXzZIybW5@RPSZmneZ9EC3VKFBFJFBeok/)
If a full program is not required:
# Python 3, ~~87~~ 84 bytes
```
lambda w,t,d:"_"+w*"="+"_"+(d-1)*("\n|"+w*" "+"|")+t*("\n|"+w*" "+"|\n+"+w*"_"+"+")
```
[Try it online!](https://tio.run/nexus/python3#XYvNCsIwEITvPsWyp82PQtqb0CcxIpEQCdhtSYNF6LuvaY/OHGbmg0mDl3cYnzHAaquNV3ygWTUOaPZG8eyUJvS8HRga3lCZ@s88m2O0T7OSPM5TqbB8l9NcMldKpGnPRi6hvD43vitIUwGGzEDOdrZXTSK9dOJ@)
[Answer]
# Javascript (ES6), ~~161~~ 157 bytes
```
f=(w,h,d)=>{r=x=>x.repeat(w);_='_';m='+'+r(_)+'+';b='|'+r(' ')+'|';c=[_+r('=')+_];for(i=d-1;i--;)
c.push(b);for(i=h;i--;)
c.push(b+'\n'+m);return c.join`\n`}
console.log(f(8,3,1));
```
[Answer]
# [Python 2](https://docs.python.org/2/), 93 bytes
```
i,j,k=input()
l=["|"+" "*i+"|"]
for x in["_"+"="*i+"_"]+l*(k-1)+(l+["+"+"_"*i+"+"])*j:print x
```
[Try it online!](https://tio.run/nexus/python2#HckxCsAgEETR3lPIVuqaIqQLeBIRu8CqGBEDFrm70TDN8P4gHXQ0lMvThGTJWHgBgYMinM@x6668c8oW/HTzuweHSYm47RJFQjvDwpUQnFThLJVy432MQ899 "Python 2 – TIO Nexus")
[Answer]
# [Perl 5](https://www.perl.org/), 85 + 1 (-a) = 86 bytes
```
say"_".'='x($w=$F[0])."_\n".($l='|'.$"x$w."|\n")x($F[2]-1).("$l+".'_'x$w."+\n")x$F[1]
```
[Try it online!](https://tio.run/##K0gtyjH9X1qcqmCqZ2BoYP2/OLFSKV5JT91WvUJDpdxWxS3aIFZTTyk@Jk9JT0Mlx1a9Rl1PRalCpVxPqQYopglU5RZtFKtrqKmnoaSSow3UGq8OltYGSwNlDWP//zdWAMJ/@QUlmfl5xf91EwE "Perl 5 – Try It Online")
[Answer]
# JavaScript/ES6, 90 bytes
I just wrote a rough solution, and happened to beat the existing JS answer by a whopping 56 bytes. Then I golfed off 11 bytes.
```
(w,h,d,g=a=>a+a[1][r='repeat'](w)+a[0]+`
`)=>g('_=')+(l=g('| '))[r](d-1)+(l+g('+_'))[r](h)
```
Here's a demo.
```
var F = (w,h,d,f=a=>a+a[1][r='repeat'](w)+a[0]+`
`)=>f('_=')+(l=f('| '))[r](d-1)+(l+f('+_'))[r](h);
console.log(F(prompt('width') || 3, prompt('height') || 3, prompt('depth') || 3));
console.log(F.toString().length);
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 23 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
|＊_⁷⇵×+×∔║│Ｐ
=×_ｅＰ⁸╷｛１⁸
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JTdDJXVGRjBBXyV1MjA3NyV1MjFGNSVENyslRDcldTIyMTQldTI1NTEldTI1MDIldUZGMzAlMEElM0QlRDdfJXVGRjQ1JXVGRjMwJXUyMDc4JXUyNTc3JXVGRjVCJXVGRjExJXUyMDc4,i=OCUwQTIlMEEz,v=1)
[Answer]
## Google Sheets, 89
Inputs A1, A2, A3.
* A4 - `_`
* A5 - (Discount 1 for `"`)
```
="|"&REPT(" ",A1)&"|
"
```
Final output (Discount 1 for `)`):
```
=A4&REPT("=",A1)&"_
"&REPT(A5,A3-1)&REPT(A5&"+"&REPT(A4,A1)&"+
",A2)
```
]