Type Casting

Type casting in computer programming allows for the conversion of variables from one data type to another, enabling programmers to manipulate and combine different types of data within their programs. It provides flexibility in handling data of varying types, facilitating interoperability between different parts of a program or between different libraries and modules. Type casting helps ensure data consistency and integrity by allowing programmers to enforce specific data types or convert data to formats suitable for particular operations or contexts. Additionally, type casting can aid in error handling and validation, allowing programmers to gracefully handle unexpected data types or conversions. Overall, type casting enhances the versatility, efficiency, and reliability of computer programs by enabling seamless interaction and manipulation of diverse data types.

Select Languages

Examples

C

double squareA(int length) {
  double area = pow(length, 2);
  return area;
}

char* squareL = "4";
int convertedVal =  atoi(squareL);
double area = squareA(convertedVal);

// converted and formatted here
char result[50];
snprintf(result, 50, "%f", area);
printf("%s", result);

C#

String squareA(int length) {
  double result = (double)(Math.Pow(length, 2));
  return result.ToString();
}

String squareL = "4";
int convertedVal = int.Parse(squareL);

String area = squareA(convertedVal);
Console.WriteLine(area);

C++

#include <iostream>
#include <math.h>
using namespace std;

string squareA(int length) {
  double result = (double)(pow(length, 2));
  return to_string(result);
}

string squareL = "4";
int convertedVal =  stoi(squareL);
string area = squareA(convertedVal);
cout << area << endl;

Go

import (
  "fmt"
  "math"
  "strconv"
)

func squareA(length int) int {
  var result =
    int(math.Pow(float64(length), float64(2)));
  return result
}

var squareL = "4"
convertedVal, err := strconv.Atoi(squareL)
  
if (err != nil) {
  fmt.Println(err);
  return;
}
  
var area = squareA(convertedVal)
fmt.Println(area)

Java

import java.lang.Math;

public static String squareA(int length) {
  double result = (double)(Math.pow(length, 2));
  String strResult = String.valueOf(result);
  return strResult;
}

String squareL = "4";
int convertedVal = Integer.valueOf(squareL);
String area = squareA(convertedVal);
System.out.println(area);

JavaScript

function squareA(length) {
  const result = Math.pow(length, 2);
  return result.toString();
}

const squareL = "4";
const convertedVal = parseInt(squareL);
const area = squareA(convertedVal);
console.log(area);

Kotlin

import kotlin.math.*

fun squareA (length: Int): String {
 val result: Double = length.toDouble().pow(2);
 return result.toString();
}

val squareL: String = "4";
val convertedVal: Int = squareL.toInt();
val area: String = squareA(convertedVal);

println(area);

MatLab

function area = squareA(length)
  result = length.^2;
  area = int2str(result);
end

// command line
squareL = "4";
convertedVal = str2num(squareL);
area = squareA(convertedVal);
display(area);

PHP

function squareA($length) {
  $result = pow($length, 2);
  return strval($result);
}

$squareL = "4";
$convertedVal = intval($squareL);
$area = squareA($convertedVal);
echo $area;

Python

def squareA(length):
  result = length ** 2
  return str(result)
 
squareL = "4"
convertedVal = int(squareL)
area = squareA(convertedVal)
print(area)

R

squareA <- function(length) {
  result <- length ^ 2;
  return (as.character(result));
}

squareL <- "4";
convertedVal <- as.numeric(squareL);
area <- squareA(convertedVal);
print(area)

Ruby

def squareA(length)
  result = length ** 2;
  return result.to_s;
end

squareL = "4"
convertedVal = squareL.to_i
area = squareA(convertedVal)
print(area)

Rust

fn squareA(length:i32)->string {
  let result = i32::pow(length, 2);
  return result.to_string();
}
  
let squareL = "4";
let convertedVal: i32 = 
  squareL.parse().expect("Not a valid number");

let area = squareA(convertedVal);
println!("{}", area);

Scala

def squareA(length:Int):String = {
  var result:Double = pow(length, 2);
  return result.toString;
}

var squareL = "4";
var convertedVal:Int = squareL.toInt;
var area:String = squareA(convertedVal);
println(area);

Swift

import Foundation

func squareA(length:Int) -> String {
  let result = pow(Double(length), 2);
  return String(result);
}

let squareL = "4";
let convertedVal:Int = Int(squareL) ?? 0;
let area = squareA(length:convertedVal);
print(area);

TypeScript

function squareA(length: number) {
  const result = Math.pow(length, 2);
  return result.toString();
}

const squareL = "4";
const convertedVal: number = parseInt(squareL);
const area:String = squareA(convertedVal);
console.log(area);

Copyright 2025. All Rights Reserved. IronCodeMan.