Truhen aus Plexiglas - Programmieraufgaben.ch

Buch Cover

Buch Cover

Buch Cover

Buch Cover

Truhen aus Plexiglas (Anweisungen und Abfolgen)

Für die Herstellung von Plexiglastruhen werden hochwertiges Plexiglas und massive Zinkrohre verbaut. Die Truhen sind quaderförmig, besitzen demnach sechs rechteckige Seitenflächen aus Plexiglas (Boden + Deckel + vier Seitenwände). Alle zwölf Kanten bestehen auf der vollen Länge aus je einem Zinkrohr. Da jede Truhe andere Maße aufweist, wird ein Programm benötigt, bei welchem die drei Größen Breite, Höhe und Tiefe (B x H x T) je in cm eingegeben werden können. Das Programm soll die total benötigte Fläche an Plexiglas (Summe der 6 Seitenflächen in cm²) und zusätzlich die benötigte totale Rohrlänge (Summe der 12 Kantenlängen) ausgeben. Geben Sie zudem das Volumen (in cm³) aus.

Zusammenfassung

Schreiben Sie ein Programm, das die folgenden Eingabedaten verarbeitet:

Eingabedaten: Breite, Höhe und Tiefe je in cm.

Ausgabe:

Rohrlänge (= totale Kantenlängen) in cm
Plexiglasfläche (= totale Oberfläche) in cm²
Volumen (= Inhalt der Truhe) in cm³

(Bemerkung: Rechteckfläche = Breite x Höhe; Quadervolumen = Breite x Höhe x Tiefe)

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

20 Lösung(en)

java
ruby
c
javascript
python
python
pl1
abap
python
csharp
cpp
ruby
python
javascript
scala
php
abap
csharp
cpp
vb

import java.util.Scanner;

public class Plexiglastruhe {
  public static void main(String[] args) {
    new Plexiglastruhe().top();
  }
  
  void top() {
    float breite = einlesen("Breite");
    float hoehe  = einlesen("Höhe");
    float tiefe  = einlesen("Tiefe");
    
    float volumen = breite * hoehe * tiefe;
    float flaeche = 2 * (breite * hoehe + 
                         breite * tiefe +
                         hoehe  * tiefe);
    float kanten  = 4 * (breite + hoehe + tiefe);
    
    ausgabe("Volumen", volumen);
    ausgabe("Fläche",  flaeche);
    ausgabe("Kanten",  kanten);
  }
  
  Scanner sc = new Scanner(System.in);
  float einlesen(String frage) {
      System.out.println("Bitte " + frage + " eingeben:");
      return sc.nextFloat();
  }
  
  void ausgabe(String mass, float wert) {
      System.out.println(mass + " beträgt " + wert);
  }
  
} // end of class Plexiglastruhe

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

#!/usr/bin/ruby
# -*- coding: utf-8 -*-

# @autor Philipp Gressly Freimann
# April 2011
#
# Aufgabe programmieraufgaben.ch
# Volumen, Oberflaeche und Kantenlänge eines Quaders berechnen


def hauptprogramm() 
  breite, tiefe, hoehe = einlesen()
  volumen, oberflaeche, kantenlaenge = berechnung(breite.to_i, tiefe.to_i, hoehe.to_i)
  ausgabe("Volumen",    volumen     )
  ausgabe("Oberfläche", oberflaeche )
  ausgabe("Kanten",     kantenlaenge)
end

def ausgabe(text, wert) 
  print "#{text}: #{wert}\n"
end

def einlesen()
  print "Breite, Tiefe und Höhe eingeben: "
  return STDIN.gets.scan(/(\d*)[,; ](\d*)[,; ](\d*)/).flatten
end

def volumenRechnen(b, t, h) 
  return b * t * h
end

def flaecheRechnen(b, t, h)
  # Deckel(Boden) + Front(Back) + Seitenwände
  return  (b*t + b*h + t*h) * 2
end

def kantenRechnen(b, t, h)
  return 4*(b + t + h)
end

def berechnung(b, t, h) 
  vol     = volumenRechnen(b, t, h)
  flaeche = flaecheRechnen(b, t, h)
  kanten  = kantenRechnen (b, t, h)
  return vol, flaeche, kanten
end

# start
hauptprogramm()

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

/* Autor: ph. gressly */
/* Datum: 19. April 2011 */
/* Volumen, Oberfläche und (totale) Kantenlänge eines Quaders. */

#include <stdio.h>

/**
 * Lesen der drei Kantenlängen Breite, Höhe, Tiefe:
 */
void eingabe(int * breite, int * hoehe, int * tiefe) {
  printf("Breite: ");
  scanf ("%d",       breite);
  printf("Höhe  : ");
  scanf ("%d",       hoehe );
  printf("Tiefe : ");
  scanf ("%d",       tiefe );
}

/**
 * Berechne Volumen, Oberfläche und Kantenlängen eines Quaders
 * bei gegebenen Kanten b(breite), h(hoehe) und t(tiefe).
 */
void berechnungen(int b, int h, int t, 
                  int* volumen, int* flaeche, int* kanten) {
  *volumen = b * h * t;
  *flaeche = 2 * (b * h + b * t + h * t);
  *kanten  = 4 * (b + t + h);
}

/**
 * Ausgabe der berechneten Werte 
 * Volumen, (Ober)fläche, totale Kanten(länge)
 */
void ausgabe(int volumen, int flaeche, int kanten) {
   printf("Volumen: %d\n", volumen);
   printf("Fläche : %d\n", flaeche);
   printf("Kanten : %d\n", kanten);
}

/**
 * Hauptprogramm:
 * Eingabe: Breite, Höhe, Tiefe
 * Ausgabe: Volumen, Fläche, (totale) Kanten(länge)
 */
main() {
  int breite, hoehe, tiefe;
  eingabe(&breite, &hoehe, &tiefe);
  
  int volumen, flaeche, kanten;
  berechnungen(breite, hoehe, tiefe, &volumen, &flaeche, &kanten);

  ausgabe(volumen, flaeche, kanten);
}

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

<?xml version="1.0" encoding="utf-8" ?>
<!-- phi@gress.ly / 19. April 2011 -->
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
  <title>Truhen aus Plexiglas</title>
  <meta   http-equiv="Content-Script-Type" content="text/javascript"/>
  <script type      ="text/javascript"     src    ="truhen.js"
  ></script>
 <link rel="stylesheet" href="truhen.css" type="text/css" />
 </head>

 <body>
  <h1>Truhen aus Plexiglas</h1>
  <p>Diese Webseite berechnet Volumen, Oberfläche und totale
  Kantenlänge einer quaderförmigen Truhe (z. B. aus Plexiglas).</p>

  <form>
   <span id="lblBreite">Breite:</span> 
     <input id="breiteInput" type="text" /><br />
   <span id="lblHoehe">Höhe:</span>

     <input id="hoeheInput" type="text"  /><br />
   <span id="lblTiefe">Tiefe:</span>
     <input id="tiefeInput" type="text"  /><br />
   <input type="button" value="Berechnen"    onclick="berechnen();" />
   <input type="reset"  value="Zurücksetzen" />
  </form>

  <p>Volumen:     <span id="volumenSpan"></span></p>

  <p>Obelfläche:  <span id="flaecheSpan"></span></p>
  <p>Kantenlänge: <span id="kantenSpan" ></span></p>
 </body>
</html>
<!-- ---------------------------------------------------- -->

/***********  truhen.js  **********************>
/**
 * Philipp Gressly Freimann
 * www.programmieraufgaben.ch (Web-Code kimn-4b4h)
 * Datum: 19. 4. 2011
 * 
 * Berechne das Volumen, die Oberfläche und die totale Kantenlänge eines Quaders.
 * 
 */

function berechnen() {
  var kanten = werteAbholen();
  ausgabe("volumen",  volumen(kanten));
  ausgabe("flaeche",  flaeche(kanten));
  ausgabe("kanten",   totaleKantenlaenge(kanten));
}

function werteAbholen() {
  var kanten = new Array(3);
  kanten[0] = wertAbholen("breite");
  kanten[1] = wertAbholen("hoehe");
  kanten[2] = wertAbholen("tiefe");
  return kanten;
}

function wertAbholen(bezeichnung) {
  var feld;
  feld = document.getElementById(bezeichnung + "Input");
  var str;
  str = feld.value;
  return str * 1; // in Zahl umwandeln
}

function ausgabe(spanId, wert) {
  span = document.getElementById(spanId + "Span");
  span.innerHTML = wert;
}

function volumen(kanten) {
  var b, h, t;
  b = kanten[0];
  h = kanten[1];
  t = kanten[2];
  return b * h * t;
}

function flaeche(kanten) {
  var b, h, t;
  b = kanten[0];
  h = kanten[1];
  t = kanten[2];    
  // Front/Back + Deckel/Boden + 2 Seitenwände
  return 2 * (b*h + b*t + h*t);
}

function totaleKantenlaenge(kanten) {
  var b, h, t;
  b = kanten[0];
  h = kanten[1];
  t = kanten[2];    
  // Jede Kante kommt 4 Mal vor.
  return 4* (b + h + t);
}

function eingabepruefung() {
 // TODO: check if input valid.  
}

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

# python3

# Plexiglaskiste
# Ausgaben:
# 1. Rohlänge in cm
# 2. Plexiglasfläche in quadrat-cm
# 3. Volumen in kubik-cm

def eingabe():
    nr = 1
    masse = list()
    while len(masse) < 3:
        try:
            i = float(input('{0}. Mass in cm: '.format(nr)))
            masse.append(i)
            nr += 1
        except:
            print('Falsche Eingabe! Bitte nochmal')

    return masse

q = eingabe()
print()
print('Rohrlänge:       {0} cm'.format((q[0]+q[1]+q[2])*2))
print('Plexiglasfläche: {0} cm\u00b2'.format(q[0]*q[1]*2 + q[0]*q[2]*2+q[1]*q[2]*2))
print('Volumen:         {0} cm\u00b3'.format(q[0]*q[1]*q[2]))

Lösung von: Frank Schneider ()

a = input("Breite = ")
b = input ("Hoehe = ")
c = input("Tiefe =" )
print "Rohrlaenge =", 4*(a + b + c), "Zentimeter"
print "Plexiglasflaeche =", 2*(a*b + a*c + b*c), "Quadratzentimeter"
print "Volumen =", a*b*c, "Kubikzentimeter"

Lösung von: Name nicht veröffentlicht

/**
 * Programmieraufgaben.CH
 *
 * date  : 2011-10-15
 * author: philipp gressly freimann (Santis Training AG)
 * PL/1: www.iron-spring.com
 */

Truhen:
  procedure options(main);
  
  declare breite       fixed(31) init(2),
          hoehe        fixed(31) init(3),
          tiefe        fixed(31) init(4);
  
  declare oberflaeche  fixed(31),
          kantenlaenge fixed(31),
          volumen      fixed(31);

  /* Berechnungen */
  volumen      = breite * hoehe * tiefe;
  kantenlaenge = 4 * (breite + tiefe + hoehe);
  oberflaeche  = 2 * (breite * tiefe + breite * hoehe + tiefe * hoehe);

  put skip list('Volumen     : ', volumen);
  put skip list('Oberflaeche : ', oberflaeche);
  put skip list('Rohrlaenge  : ', kantenlaenge);

end Truhen;

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

*&---------------------------------------------------------------------*
*& Report  Z_PLEXIGLAS_TRUHEN
*&
*&---------------------------------------------------------------------*
*& 
*& Programmiersprache ist eigentlch ABAP
*&---------------------------------------------------------------------*

REPORT  Z_PLEXIGLAS_TRUHEN.

set BLANK LINES on.

PARAMETERS: l_width TYPE p DECIMALS 2,
            l_height TYPE p DECIMALS 2,
            l_depth TYPE p DECIMALS 2.


DATA: l_pipelength_result TYPE p DECIMALS 2,
      l_area_result TYPE p DECIMALS 2,
      l_volume_result TYPE p DECIMALS 2.


l_pipelength_result = 4 * l_width + 4 * l_height + 4 * l_depth.

l_area_result = 2 * l_height * l_width + 2 * l_width * l_depth + 2 * l_height * l_depth.

l_volume_result = l_height * l_width * l_depth.

WRITE: /, 'Plexi-Box Calculator'.

uline.

WRITE: / l_pipelength_result, ' cm pipes are neccessary.'.
WRITE: / 'Moreover the area of the Box amounts ', l_area_result, ' square centimeters'.
WRITE: / 'And t

Lösung von: Benjamin Kluszynski (( Coder :-) ))

"""Truhen aus Plexigals"""

b = float(input("Breite: "))
h = float(input("Höhe: "))
t = float(input("Tiefe: "))

def flaeche(b,h,t):
    if b == t == h:
        die_flaeche = b*t*6
    else:
        die_flaeche = (b*h*2)+(b*t*2)+(t*h*2)
    print("Die Fläche der Truhe beträgt ", die_flaeche, "cm²")

def volumen(b,h,t):
    das_volumen = b*h*t
    print("Das Volumen der Truhe beträgt ", das_volumen, "cm³")

def kanten (b,h,t):
    die_kanten = b*4+t*4+h*4
    print("Die Länge der Rohre beträgt ", die_kanten, "cm")

flaeche(b,h,t)
volumen(b,h,t)
kanten(b,h,t)

Lösung von: Py Thon ()

static void Main(string[] args)
        {
            double x, y, z;
            Console.Write("Breite: ");
            string Breite = Console.ReadLine();
            x = Convert.ToDouble(Breite);

            Console.Write("Höhe: ");
            string Höhe = Console.ReadLine();
            y = Convert.ToDouble(Höhe);

            Console.Write("Tiefe: ");
            string Tiefe = Console.ReadLine();
            z = Convert.ToDouble(Tiefe);

            Console.WriteLine("Rohrlänge: " + (4*x + 4*y + 4*z) + " cm");
            Console.WriteLine("Plexiglasfläche: " + (2*x*y+2*x*z+2*y*z) + " cm^2");
            Console.WriteLine("Volumen: " + x*y*z + " cm^3");

            Console.ReadKey();
        }

// Autor:				Andy Großhennig
// Solution for task:	Truhen aus Plexiglas (Anweisungen und Abfolgen)

#include <iostream>

using namespace std;

// Structure: Define the chest
struct chest
{
	double d_arrXYZ[3];
	double dChestVolume, dGlassArea, dTubeLength; // Twelve borders
};

// Function: Get Width, Length and High
void getData(chest *chest)
{
	printf("Geben sie die Groessen der Truhe an:\n\nX: ");
	cin >> chest->d_arrXYZ[0];
	printf("\nY: ");
	cin >> chest->d_arrXYZ[1];
	printf("\nZ: ");
	cin >> chest->d_arrXYZ[2];
}

// Function: Calculate the length of the tubes, the size of the area of glass and the volume of the chest
void calculate()
{
	chest chest;

	getData(&chest);

	chest.dTubeLength = (chest.d_arrXYZ[0] * 4) + (chest.d_arrXYZ[1] * 4) + (chest.d_arrXYZ[2] * 4);

	chest.dGlassArea = ((chest.d_arrXYZ[0] * chest.d_arrXYZ[1]) * 2) + ((chest.d_arrXYZ[0] * chest.d_arrXYZ[2]) * 2) + ((chest.d_arrXYZ[1] * chest.d_arrXYZ[2]) * 2);

	chest.dChestVolume = chest.d_arrXYZ[0] * chest.d_arrXYZ[1] * chest.d_arrXYZ[2];

	printf("\n\nDie benoetigte Rohrlaenge betraegt: %.3f \nDie benoetigte Flaeche an Plexiglas betraegt: %.3f \nDas Volumen der Truhe betraegt: %.3f", chest.dTubeLength, chest.dGlassArea, chest.dChestVolume);
}

int main()
{
	calculate();
	
	printf("\n\n");
	system("Pause");
	return 0;
}

Lösung von: Andy Großhennig (Bundeswehr)

puts "Breite eingeben:"
width = gets.chomp.to_i
puts "Höhe eingeben:"
height = gets.chomp.to_i
puts "Tiefe eingeben:"
depth = gets.chomp.to_i

puts "Das Volumen beträgt #{width*height*depth} cm3"
puts "Die Plexiglasfläche beträgt #{2*(width*height)+2*(height*depth)+2*(width*depth)} cm2"
puts "Die totale Kantenlänge beträgt #{(4*width)+(4*height)+(4*depth)} cm"

Lösung von: Name nicht veröffentlicht

breite = int(input('Breadth: '))
hoehe = int(input('Hight: '))
tiefe = int(input('Depth: '))

volumen = breite * hoehe * tiefe

glasflaeche = (2 * breite * hoehe) + (2 * tiefe * hoehe) + (2 * breite * tiefe)

kantenlaenge = (breite + tiefe + hoehe) * 4

print('You will need', kantenlaenge, 'cm of zinc pipe,',
      glasflaeche, 'square cm of acrylic glass, and',
      'the volume is', volumen, 'cubic centimeters.')

Lösung von: Hilli Hilli ()

// eingabemaske
document.write(
   '<input type="number" id="width" onchange="compute()"> Breite (cm)<br>' +
   '<input type="number" id="height" onchange="compute()"> Höhe (cm)<br>' +
   '<input type="number" id="depth" onchange="compute()"> Tiefe (cm)<br>'+
   '<p id="out"></p>'
);

function compute() {
   var w = document.getElementById("width").value,
       h = document.getElementById("height").value,
       d = document.getElementById("depth").value;
       
    document.getElementById("out").innerHTML =
      'Rohrlänge: ' + (4 * w + 4 * h + 4 * d).toFixed(2) + ' cm<br>' + 
      'Plexiglasfläche: ' + (2 * w * h + 2 * h * d + 2 * w * d).toFixed(2) + 
         ' cm²<br>' +
      'Volumen: ' + (w * d * h).toFixed(2) + 'cm³';
}

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

object PlexiGlasCalc extends App {
def VolumenCalc(x:Int , y:Int , z:Int) : Int = {
  var Volumen = x*y*z
  return Volumen
}  
def PlexiGlasCalc(x:Int , y:Int , z:Int) : Int = {
  var Oberflaeche = 2*(x*y) + 2*(x*z) + 2*(y*z)
  return Oberflaeche 
}
def KantenCalc(x:Int , y:Int , z:Int) : Int = {
  var Kanten = (4*y)+(4*z)+(4*x)
  return Kanten
}
println("Plexiglas Rechner 2015 Scala")
println("Geben Sie die Höhe ein")
var hoehe:Int = scala.io.StdIn.readInt()
println("Geben Sie die Breite ein")
var breite:Int = scala.io.StdIn.readInt()
println("Geben sie die Tiefe ein")
var tiefe:Int = scala.io.StdIn.readInt()
var Volumen = VolumenCalc(hoehe,breite,tiefe)
var PlexiGlasGes = PlexiGlasCalc(hoehe,breite,tiefe)
var KantenLaenge = KantenCalc(hoehe,breite,tiefe)
println("Das Volumen beträgt: " + Volumen + "cm³")
println("Die Gesamt Fläche des Plexiglases beträgt " + PlexiGlasGes + "cm²")
println("Die Gesamt KantenLänge beträgt beträgt " + KantenLaenge + "cm")
}

Lösung von: Name nicht veröffentlicht

HTML-Code:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="plexiglas.php" method="post">
    <input type="number" min="0" name="num1"> Länge (in cm)<br></input>
    <input type="number" min="0" name="num2"> Breite (in cm)<br></input>
    <input type="number" min="0" name="num3"> Höhe (in cm)<br></input>
    <input type="submit" value="Abschicken" /><input type="reset" />
</form>


</body>
</html>



PHP-Code:


<?php

$x = $_POST["num1"];
$y = $_POST["num2"];
$z = $_POST["num3"];


$volumen = $x * $y * $z;
$plexi = (($x * $z) * 4) + (($y * $z) * 2);
$rohr = $x * 4 + $y * 4 + $z * 4;

echo "Das Volumen beträgt: " . $volumen . " cm³<br>";
echo "Die Plexiglasfläche beträgt: " . $plexi . " cm²<br>";
echo "Die Rohrlänge beträgt: " . $rohr . " cm<br>";

?>

Lösung von: Maik Scheiermann (Powercloud GmbH)

REPORT TRUHE.

PARAMETERS: lv_laeng TYPE i,
            lv_breit TYPE i,
            lv_hoehe TYPE i.

DATA: lv_kanten  TYPE i,
      lv_flaeche TYPE i,
      lv_vol     TYPE i.

lv_kanten  = ( 4 * lv_laeng ) + ( 4 * lv_breit ) + ( 4 * lv_hoehe ).
lv_flaeche = ( 2 * lv_laeng * lv_breit ) + ( 2 * lv_laeng * lv_hoehe ) + ( 2 * lv_breit * lv_hoehe ).
lv_vol     = lv_laeng * lv_breit * lv_hoehe.

WRITE:/ 'Kantenlängen:',lv_kanten,' cm'.
NEW-LINE.
WRITE:/ 'Fläche      :',lv_flaeche,' cm2'.
NEW-LINE.
WRITE:/ 'Volumen     :',lv_vol,' cm3'.

Lösung von: Name nicht veröffentlicht

// NET 6.x | C# 10.x | VS-2022

Console.Write("Bitte Breite, Tiefe und Hoehe leerzeichengetrennt als Dezimalzahl eingeben: ");

var input = Console.ReadLine();
if (string.IsNullOrEmpty(input)) return;

var arr = input.Replace(".", ",").Split(" ").Where(x => double.TryParse(x, out var n) && n > 0).Select(x => double.Parse(x)).ToArray();
if (arr.Length != 3) return;

var (length, area, volume) = Cuboid(arr[0], arr[1], arr[2]);
Console.WriteLine($"Kantenlaenge: {length:0.##}\nOberflaeche: {area:0.##}\nVolumen: {volume:0.##}");

static (double length, double area, double volume) Cuboid(double width, double depth, double height) =>
    (4 * (depth + width + height), 2 * (depth * height + width * height + depth * width), depth * width * height);

// kürzer, da ohne Funktion und ohne Überprüfung der Eingaben

Console.Write("Breite: ");
_ = double.TryParse(Console.ReadLine(), out var w);
Console.Write("Tiefe: ");
_ = double.TryParse(Console.ReadLine(), out var d);
Console.Write("Hoehe: ");
_ = double.TryParse(Console.ReadLine(), out var h);

Console.WriteLine($"Kantenlaenge: {4 * (d + w + h):0.##}\nOberflaeche: {2 * (d * h + w * h + d * w):0.##}\nVolumen: {d * w * h:0.##}");

Lösung von: Jens Kelm (@JKooP)

// C++ 17 | VS-2022
#include <iostream>

class Cuboid {
    double width_, depth_, height_;
public:
    Cuboid(double width, double depth, double height) : width_{ width }, depth_{ depth }, height_{ height } {};
    double get_length(), get_area(), get_volume();
    friend std::ostream& operator<<(std::ostream&, Cuboid&);
};

double Cuboid::get_length() {
    return 4 * (depth_ + width_ + height_);
}

double Cuboid::get_area() {
    return 2 * (depth_ * height_ + width_ * height_ + depth_ * width_);
}

double Cuboid::get_volume() {
    return depth_ * width_ * height_;
}

std::ostream& operator<<(std::ostream& os, Cuboid& c) {
    os << "Laenge: " << c.get_length() << "\n";
    os << "Flaeche: " << c.get_area() << "\n";
    os << "Volumen: " << c.get_volume() << "\n";
    return os;
}

int main() {
    // ohne Abfangen von Fehleingaben
    double width{}, depth{}, height{};
    std::cout << "Breite: "; std::cin >> width;
    std::cout << "Tiefe: "; std::cin >> depth;
    std::cout << "Hoehe: "; std::cin >> height;
    Cuboid cuboid(width, depth, height);
    std::cout << cuboid << "\n";
}

Lösung von: Jens Kelm (@JKooP)

' VBA
' Klassenmodul "Cuboid":
Private width_ As Double
Private depth_ As Double
Private height_ As Double

Public Sub Init(ByVal width As Double, ByVal depth As Double, ByVal height As Double)
    width_ = width
    depth_ = depth
    height_ = height
End Sub

Public Property Get P_Length() As Double
    P_Length = 4 * (depth_ + width_ + height_)
End Property

Public Property Get P_Area() As Double
    P_Area = 2 * (depth_ * height_ + width_ * height_ + depth_ * width_)
End Property

Public Property Get P_Volume() As Double
    P_Volume = depth_ * width_ * height_
End Property

Public Function ToString()
    ToString = "Länge: " & P_Length & vbCrLf & "Fläche: " & P_Area & vbCrLf & "Volumen: " & P_Volume
End Function

' Modul "Main"
Public Sub Main()
    Const width# = 2
    Const depth# = 3
    Const height# = 4
    
    Dim c As New Cuboid
    c.Init width, depth, height
    
    Debug.Print c.ToString
End Sub

Lösung von: Jens Kelm (@JKooP)

Verifikation/Checksumme:

Breite = 2, Höhe=3, Tiefe=4

Volumen = 24 cm³

Oberfläche = 52 cm²

Rohrlänge = 36 cm