Classe de scanner Java

le Scanner classe de la java.util package est utilisé pour lire les données d’entrée de différentes sources telles que les flux d’entrée, les utilisateurs, les fichiers, etc. Prenons un exemple.


Exemple 1: lire une ligne de texte à l’aide du scanner

 import java.util.Scanner;

class Main {
    public static void main(String[] args) {

        // Creates an object of Scanner
        Scanner input = new Scanner(System.in);

        System.out.print("Enter your name: ");

        // Takes input from the keyboard
        String name = input.nextLine();

        // Prints name
        System.out.println("My name is " + name);

        // Closes the scanner
        input.close();
    }
}
 

Production

Entrez votre nom: Jack
Mon nom est Jack

Dans l’exemple ci-dessus, notez la ligne

 Scanner input = new Scanner(System.in);
 

Ici, nous avons créé un objet de Scanner nommécontribution.

le System.in Le paramètre est utilisé pour prendre l’entrée de l’entrée standard. Cela fonctionne comme si vous preniez des entrées sur le clavier.

Nous avons ensuite utilisé le nextLine() méthode de la Scanner classe pour lire une ligne de texte de l’utilisateur.

Maintenant que vous avez une idée sur Scanner , explorons plus à ce sujet.


Importer une classe de scanner

Comme nous pouvons le voir dans l’exemple ci-dessus, nous devons importer le java.util.Scanner package avant de pouvoir utiliser le Scanner classe.

 import java.util.Scanner;
 

Créer un objet Scanner en Java

Une fois que nous importons le package comme mentionné ci-dessus, voici comment nous pouvons créer Scanner objets.

 // To read input from the input stream
Scanner sc1 = new Scanner(InputStream input);

// To read input from files
Scanner sc2 = new Scanner(File file);

// To read input from a string
Scanner sc3 = new Scanner(String str);
 

Ici, nous avons créé des objets du Scanner classe qui lira respectivement l’entrée de InputStream, des fichiers et de la chaîne.


Méthodes du scanner Java pour prendre des entrées

le Scanner La classe fournit diverses méthodes qui nous permettent de lire des entrées de différents types.

Méthode La description
 nextInt()  lit un int valeur de l’utilisateur
 nextFloat()  lit un float valeur de l’utilisateur
 nextBoolean()  lit un boolean valeur de l’utilisateur
 nextLine()  lit une ligne de texte de l’utilisateur
 next()  lit un mot de l’utilisateur
 nextByte()  lit un byte valeur de l’utilisateur
 nextDouble()  lit un doubl e valeur de l’utilisateur
 nextShort()  lit un short valeur de l’utilisateur
 nextLong()  lit un long valeur de l’utilisateur

Exemple 2: Java Scanner nextInt ()

 import java.util.Scanner;

class Main {
    public static void main(String[] args) {

        // creating a Scanner object
        Scanner input = new Scanner(System.in);

        System.out.println("Enter an integer: ");

        // read an int value
        int data1 = input.nextInt();

        System.out.println("Using nextInt(): " + data1);

        input.close();
    }
}
 

Production

Entrez un entier:
22
Utilisation de nextInt (): 22

Dans l’exemple ci-dessus, nous avons utilisé le nextInt() méthode pour lire une valeur entière.


Exemple 3: Java Scanner nextDouble ()

 import java.util.Scanner;

class Main {
   public static void main(String[] args) {

      // creates an object of Scanner
      Scanner input = new Scanner(System.in);
      System.out.print("Enter double value: ");

      // reads the double value
      double value = input.nextDouble();
      System.out.println("Using nextDouble(): " + value);

      input.close();
   }
}
 

Production

Entrez la valeur double: 33,33
Utilisation de nextDouble (): 33,33

Dans l’exemple ci-dessus, nous avons utilisé le nextDouble() méthode pour lire une valeur à virgule flottante.


Exemple 4: Scanner Java suivant ()

 import java.util.Scanner;

class Main {
   public static void main(String[] args) {

      // creates an object of Scanner
      Scanner input = new Scanner(System.in);
      System.out.print("Enter your name: ");

      // reads the entire word 
      String value = input.next();
      System.out.println("Using next(): " + value);

      input.close();
   }
}
 

Production

Entrez votre nom: Jonny Walker
Utilisation de next (): Jonny

Dans l’exemple ci-dessus, nous avons utilisé le next() méthode pour lire une chaîne de l’utilisateur.

Ici, nous avons fourni le nom complet. Cependant, le next() La méthode ne lit que le prénom.

C’est parce que le next() la méthode lit l’entrée jusqu’à laespace blancpersonnage. Une fois laespace blancest rencontré, il renvoie la chaîne (à l’exclusion des espaces).


Exemple 5: Java Scanner nextLine ()

 import java.util.Scanner;

class Main {
   public static void main(String[] args) {

      // creates an object of Scanner
      Scanner input = new Scanner(System.in);
      System.out.print("Enter your name: ");

      // reads the entire line
      String value = input.nextLine();
      System.out.println("Using nextLine(): " + value);

      input.close();
   }
}
 

Production

Entrez votre nom: Jonny Walker
Utilisation de nextLine (): Jonny Walker

Dans le premier exemple, nous avons utilisé le nextLine() méthode pour lire une chaîne de l’utilisateur.

contrairement à next() , les nextLine() La méthode lit toute la ligne d’entrée, y compris les espaces. La méthode se termine lorsqu’elle rencontre un caractère de ligne suivant, \n .

Lecture recommandée:Le scanner Java ignore la nextLine ().


Scanner Java avec BigInteger et BigDecimal

Le scanner Java peut également être utilisé pour lire les grands nombres entiers et décimaux. Pour en savoir plus sur BigInteger et BigDecimal, visitezJava BigIntegeretJava BigDecimal.

  •  nextBigInteger() – lit la grande valeur entière de l’utilisateur
  •  nextBigDecimal() – lit la grande valeur décimale de l’utilisateur

Exemple 4: Lire BigInteger et BigDecimal

 import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Scanner;

class Main {
   public static void main(String[] args) {

      // creates an object of Scanner
      Scanner input = new Scanner(System.in);
      System.out.print("Enter a big integer: ");

      // reads the big integer
      BigInteger value1 = input.nextBigInteger();
      System.out.println("Using nextBigInteger(): " + value1);

      System.out.print("Enter a big decimal: ");

      // reads the big decimal
      BigDecimal value2 = input.nextBigDecimal();
      System.out.println("Using nextBigDecimal(): " + value2);

      input.close();
   }
}
 

Production

Entrez un grand entier: 987654321
Utilisation de nextBigInteger (): 987654321
Entrez une grande décimale: 9,55555
Utilisation de nextBigDecimal (): 9.55555

Dans l’exemple ci-dessus, nous avons utilisé le java.math.BigInteger et java.math.BigDecimal paquet à lire BigInteger et BigDecimal respectivement.


Fonctionnement du scanner Java

le Scanner class lit une ligne entière et divise la ligne en jetons. Les jetons sont de petits éléments qui ont une certaine signification pour le compilateur Java. Par exemple,

Supposons qu’il y ait une chaîne d’entrée:

 He is 22
 

Classe Java FileInputStream

le FileInputStream classe de la java.io package peut être utilisé pour lire des données (en octets) à partir de fichiers.

Il étend le InputStream classe abstraite.

Java FileInputStream is a subclass of InputStream class.

Avant d’en savoir plus sur FileInputStream , assurez-vous de connaître les fichiers Java.


Créer un FileInputStream

Afin de créer un flux d’entrée de fichier, nous devons importer le java.io.FileInputStream paquet en premier. Une fois le package importé, voici comment créer un flux d’entrée de fichier en Java.

1. Utilisation du chemin d’accès au fichier

 FileInputStream input = new FileInputStream(stringPath);
 

Ici, nous avons créé un flux d’entrée qui sera lié au fichier spécifié par lechemin.

2. Utilisation d’un objet du fichier

 FileInputStream input = new FileInputStream(File fileObject);
 

Ici, nous avons créé un flux d’entrée qui sera lié au fichier spécifié par fileObject .


Méthodes de FileInputStream

le FileInputStream classe fournit des implémentations pour différentes méthodes présentes dans le InputStream classe.

read (), méthode

  •  read() – lit un seul octet du fichier
  •  read(byte[] array) – lit les octets du fichier et les stocke dans le tableau spécifié
  •  read(byte[] array, int start, int length) – lit le nombre d’octets égal àlongueurà partir du fichier et stocke dans le tableau spécifié à partir de la positiondébut

Supposons que nous ayons un fichier nomméinput.txtavec le contenu suivant.

 This is a line of text inside the file.
 

Essayons de lire ce fichier en utilisant FileInputStream .

 import java.io.FileInputStream;

public class Main {

  public static void main(String args[]) {

     try {
        FileInputStream input = new FileInputStream("input.txt");

        System.out.println("Data in the file: ");

        // Reads the first byte
        int i = input.read();

       while(i != -1) {
           System.out.print((char)i);

           // Reads next byte from the file
           i = input.read();
        }
        input.close();
     }

     catch(Exception e) {
        e.getStackTrace();
     }
  }
}
 

Production

Données dans le fichier:
Il s'agit d'une ligne de texte à l'intérieur du fichier.

Dans l’exemple ci-dessus, nous avons créé un flux d’entrée de fichier nommécontribution. Le flux d’entrée est lié auinput.txtfichier.

 FileInputStream input = new FileInputStream("input.txt");
 

Pour lire les données du fichier, nous avons utilisé le read() méthode à l’intérieur de la boucle while.


available () Méthode

Pour obtenir le nombre d’octets disponibles, nous pouvons utiliser le available() méthode. Par exemple,

 import java.io.FileInputStream;

public class Main {

   public static void main(String args[]) {

      try {
         // Suppose, the input.txt file contains the following text
         // This is a line of text inside the file.
         FileInputStream input = new FileInputStream("input.txt");

         // Returns the number of available bytes
         System.out.println("Available bytes at the beginning: " + input.available());

         // Reads 3 bytes from the file
         input.read();
         input.read();
         input.read();

         // Returns the number of available bytes
         System.out.println("Available bytes at the end: " + input.available());

         input.close();
      }

      catch (Exception e) {
         e.getStackTrace();
      }
   }
}
 

Production

Octets disponibles au début: 39
Octets disponibles à la fin: 36

Dans l’exemple ci-dessus,

  1. Nous utilisons d’abord le available() pour vérifier le nombre d’octets disponibles dans le flux d’entrée du fichier.
  2. Nous avons ensuite utilisé le read() méthode 3 fois pour lire 3 octets dans le flux d’entrée du fichier.
  3. Maintenant, après avoir lu les octets, nous avons à nouveau vérifié les octets disponibles. Cette fois, les octets disponibles ont diminué de 3.

skip (), méthode

Pour supprimer et ignorer le nombre d’octets spécifié, nous pouvons utiliser le skip() méthode. Par exemple,

 import java.io.FileInputStream;

public class Main {

   public static void main(String args[]) {

      try {
         // Suppose, the input.txt file contains the following text
         // This is a line of text inside the file.
         FileInputStream input = new FileInputStream("input.txt");

         // Skips the 5 bytes
         input.skip(5);
         System.out.println("Input stream after skipping 5 bytes:");

         // Reads the first byte
         int i = input.read();
         while (i != -1) {
            System.out.print((char) i);

            // Reads next byte from the file
            i = input.read();
         }

         // close() method
         input.close();
      }
      catch (Exception e) {
         e.getStackTrace();
      }
   }
}
 

Production

Flux d'entrée après avoir sauté 5 octets:
est une ligne de texte à l'intérieur du fichier.

Dans l’exemple ci-dessus, nous avons utilisé le skip() pour ignorer 5 octets de données du flux d’entrée du fichier. Par conséquent, les octets représentant le texte« Ce « n’est pas lu à partir du flux d’entrée.


close (), méthode

Pour fermer le flux d’entrée du fichier, nous pouvons utiliser le close() méthode. Une fois la close() est appelée, nous ne pouvons pas utiliser le flux d’entrée pour lire les données.

Dans tous les exemples ci-dessus, nous avons utilisé le close() méthode pour fermer le flux d’entrée du fichier.


Autres méthodes de FileInputStream

Méthodes Descriptions
 finalize()     garantit que le close() la méthode est appelée
 getChannel()     renvoie l’objet de FileChannel associé au flux d’entrée
 getFD()     renvoie le descripteur de fichier associé au flux d’entrée
 mark()   marquer la position dans le flux d’entrée jusqu’à laquelle les données ont été lues
 reset()  

C ++ fwscanf ()

La fonction fwscanf () est définie dansEn tête de fichier.

prototype fwscanf ()

int fwscanf (FILE * stream, const wchar_t * format, ...);

La fonction fwscanf () lit les données du flux de fichiers et stocke les valeurs dans les variables respectives.


Paramètres de fwscanf ()

  • courant: Le flux de fichier d’entrée à partir duquel lire les données.
  • format: Pointeur vers une chaîne de caractères terminée par un zéro qui spécifie comment lire l’entrée. Il se compose de spécificateurs de format commençant par%.
    La chaîne de format comprend les parties suivantes:
    • Caractères non blancs sauf% dont chacun consomme un caractère identique du flux d’entrée. Cela peut entraîner l’échec de la fonction si le caractère suivant du flux ne se compare pas.
    • Caractère d’espacement: tous les caractères d’espacement consécutifs sont traités comme un seul caractère d’espacement. De plus, ‘\ n’, ‘\ t’ et  » sont considérés comme identiques.
    • Spécification de conversion: elle suit le format suivant:
      • Caractère% initial qui spécifie le début
      • Un caractère facultatif * appelé de suppression d’affectation. Si ce caractère est présent, fwscanf () n’affecte le résultat à aucun argument de réception.
      • Un nombre entier positif facultatif qui spécifie la largeur maximale du champ. Il spécifie le nombre maximum de caractères que fwscanf () est autorisé à consommer lors de la conversion spécifiée par la spécification de conversion actuelle.
      • Un modificateur de longueur facultatif spécifiant la taille de l’argument de réception.
      • Un spécificateur de format de conversion.
    Spécificateurs de format
    Spécificateur de format La description
    % Correspond au% littéral
    c Correspond à un ou plusieurs caractères. Si la largeur est définie, correspond exactement aux caractères de largeur.
    s Correspond aux caractères non blancs consécutifs. Si la largeur est définie, correspond exactement aux caractères de largeur ou jusqu’à ce que le premier espace soit trouvé.
    [ensemble] Correspond à une séquence non vide de caractères du jeu de caractères donné. Si ^ est présent au début de l’ensemble, alors tous les caractères qui ne sont pas dans l’ensemble sont mis en correspondance.
    Correspond à un entier décimal.
    je Correspond à un entier.
    o Correspond à un entier octal non signé.
    X ou x Correspond à un entier hexadécimal non signé.
    u Correspond à un entier décimal non signé.
    A ou an, E ou e, F ou f, G ou g Correspond à un nombre à virgule flottante.
    n Renvoie le nombre de caractères lus jusqu’à présent.
    p Correspond à une séquence de caractères définie par l’implémentation définissant un pointeur.

    Ainsi, le format général du spécificateur de format est:

    Spécificateur% [*] [largeur] [longueur]
  • …: Autres arguments supplémentaires pour recevoir des données. Ils se produisent dans une séquence selon le spécificateur de format.

fwscanf () Valeur renvoyée

  • La fonction fwscanf () renvoie le nombre d’arguments de réception attribués avec succès.
  • Si un échec se produit avant que le premier argument de réception ne soit attribué, EOF est renvoyé.

Exemple: comment fonctionne la fonction fwscanf ()?

 #include <cwchar>
#include <clocale>
#include <cwctype>
#include <cstdio>

int main()
{
FILE *fp = fopen("example.txt","w+");
wchar_t str[10], ch;

setlocale(LC_ALL, "en_US.UTF-8");
fwprintf(fp, L"%ls %lc", L"Summation", L'\u2211');
fwprintf(fp, L"%ls %lc", L"Integral", L'\u222b');

rewind(fp);

while((fwscanf(fp, L"%ls %lc", str, &ch))!=EOF)
{
wprintf(L"%lc is %ls\n", ch, str);
}

fclose(fp);
return 0;
}
 

Java PriorityQueue

le PriorityQueue class fournit les fonctionnalités de la structure de données du tas.

Il implémente l’interface de file d’attente.

The Java PriorityQueue class implements the Queue interface.

Contrairement aux files d’attente normales, les éléments de la file d’attente prioritaire sont récupérés dans l’ordre trié.

Supposons que nous souhaitons récupérer les éléments dans l’ordre croissant. Dans ce cas, la tête de la file d’attente prioritaire sera le plus petit élément. Une fois cet élément récupéré, le plus petit élément suivant sera la tête de la file d’attente.

Il est important de noter que les éléments d’une file d’attente prioritaire peuvent ne pas être triés. Cependant, les éléments sont toujours récupérés dans un ordre trié.


Création de PriorityQueue

Afin de créer une file d’attente prioritaire, nous devons importer le java.util.PriorityQueue paquet. Une fois le package importé, voici comment créer une file d’attente prioritaire en Java.

 PriorityQueue<Integer> numbers = new PriorityQueue<>();
 

Ici, nous avons créé une file d’attente prioritaire sans aucun argument. Dans ce cas, la tête de la file d’attente prioritaire est le plus petit élément de la file d’attente. Et les éléments sont supprimés par ordre croissant de la file d’attente.

Cependant, nous pouvons personnaliser l’ordre des éléments à l’aide du Comparator interface. Nous en apprendrons plus tard dans ce didacticiel.


Méthodes de PriorityQueue

le PriorityQueue classe fournit l’implémentation de toutes les méthodes présentes dans le Queue interface.


Insérer des éléments dans PriorityQueue

  •  add() – Insère l’élément spécifié dans la file d’attente. Si la file d’attente est pleine, elle lève une exception.
  •  offer() – Insère l’élément spécifié dans la file d’attente. Si la file d’attente est pleine, elle renvoie false .

Par exemple,

 import java.util.PriorityQueue;

class Main {
    public static void main(String[] args) {

        // Creating a priority queue
        PriorityQueue<Integer> numbers = new PriorityQueue<>();

        // Using the add() method
        numbers.add(4);
        numbers.add(2);
        System.out.println("PriorityQueue: " + numbers);

        // Using the offer() method
        numbers.offer(1);
        System.out.println("Updated PriorityQueue: " + numbers);
    }
}
 

Production

PriorityQueue: [2, 4]
PriorityQueue mis à jour: [1, 4, 2]

Ici, nous avons créé une file d’attente prioritaire nomméeNombres. Nous avons inséré 4 et 2 dans la file d’attente.

Bien que 4 soit inséré avant 2, la tête de la file d’attente est 2. C’est parce que la tête de la file d’attente prioritaire est le plus petit élément de la file d’attente.

Nous avons ensuite inséré 1 dans la file d’attente. La file d’attente est maintenant réorganisée pour stocker le plus petit élément 1 à la tête de la file d’attente.


Accès aux éléments PriorityQueue

Pour accéder aux éléments d’une file d’attente prioritaire, nous pouvons utiliser le peek() méthode. Cette méthode renvoie la tête de la file d’attente. Par exemple,

 import java.util.PriorityQueue;

class Main {
    public static void main(String[] args) {

        // Creating a priority queue
        PriorityQueue<Integer> numbers = new PriorityQueue<>();
        numbers.add(4);
        numbers.add(2);
        numbers.add(1);
        System.out.println("PriorityQueue: " + numbers);

        // Using the peek() method
        int number = numbers.peek();
        System.out.println("Accessed Element: " + number);
    }
}
 

Production

PriorityQueue: [1, 4, 2]
Élément consulté: 1

Supprimer les éléments PriorityQueue

  •  remove() – supprime l’élément spécifié de la file d’attente
  •  poll() – retourne et supprime la tête de la file d’attente

Par exemple,

 import java.util.PriorityQueue;

class Main {
    public static void main(String[] args) {

        // Creating a priority queue
        PriorityQueue<Integer> numbers = new PriorityQueue<>();
        numbers.add(4);
        numbers.add(2);
        numbers.add(1);
        System.out.println("PriorityQueue: " + numbers);

        // Using the remove() method
        boolean result = numbers.remove(2);
        System.out.println("Is the element 2 removed? " + result);

        // Using the poll() method
        int number = numbers.poll();
        System.out.println("Removed Element Using poll(): " + number);
    }
}
 

Production

PriorityQueue: [1, 4, 2]
L'élément 2 est-il supprimé? vrai
Élément supprimé à l'aide de poll (): 1

Itération sur une PriorityQueue

Pour parcourir les éléments d’une file d’attente prioritaire, nous pouvons utiliser le iterator() méthode. Pour utiliser cette méthode, nous devons importer le java.util.Iterator paquet. Par exemple,

 import java.util.PriorityQueue;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {

        // Creating a priority queue
        PriorityQueue<Integer> numbers = new PriorityQueue<>();
        numbers.add(4);
        numbers.add(2);
        numbers.add(1);
        System.out.print("PriorityQueue using iterator(): ");

        //Using the iterator() method
        Iterator<Integer> iterate = numbers.iterator();
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}
 

Production

PriorityQueue utilisant iterator (): 1, 4, 2,

Autres méthodes PriorityQueue

Méthodes Descriptions
 contains(element)  Recherche dans la file d’attente prioritaire l’élément spécifié. Si l’élément est trouvé, il renvoie true , sinon ça revient false .
 size()  Renvoie la longueur de la file d’attente prioritaire.
 toArray()  Convertit une file d’attente prioritaire en tableau et la renvoie.

Comparateur PriorityQueue

Dans tous les exemples ci-dessus, les éléments de la file d’attente prioritaire sont récupérés dans l’ordre naturel (ordre croissant). Cependant, nous pouvons personnaliser cette commande.

Pour cela, nous devons créer notre propre classe de comparaison qui implémente le Comparator interface. Par exemple,

 import java.util.PriorityQueue;
import java.util.Comparator;
class Main {
    public static void main(String[] args) {

        // Creating a priority queue
        PriorityQueue<Integer> numbers = new PriorityQueue<>(new CustomComparator());
        numbers.add(4);
        numbers.add(2);
        numbers.add(1);
        numbers.add(3);
        System.out.print("PriorityQueue: " + numbers);
    }
}

class CustomComparator implements Comparator<Integer> {

    @Override
    public int compare(Integer number1, Integer number2) {
        int value =  number1.compareTo(number2);
        // elements are sorted in reverse order
        if (value > 0) {
            return -1;
        }
        else if (value < 0) {
            return 1;
        }
        else {
            return 0;
        }
    }
}
 

Production

PriorityQueue: [4, 3, 1, 2]

Dans l’exemple ci-dessus, nous avons créé une file d’attente prioritaire passantComparateur personnaliséclasse comme argument.

leComparateur personnaliséclasse implémente le Comparator interface.

Nous annulons ensuite le compare() 

Appel de fonction Kotlin Infix

Avant d’apprendre à créer une fonction ayant une notation infixe, explorons deux fonctions infixes couramment utilisées.

Lorsque vous utilisez || et && opérations, le compilateur recherche respectivement ou et et fonctions, et les appelle sous le capot.

Ces deux fonctions prennent en charge la notation infixe.


Example: Kotlin or & and function

 fun main(args: Array<String>) {
    val a = true
    val b = false
    var result: Boolean

    result = a or b // a.or(b)
    println("result = $result")

    result = a and b // a.and(b)
    println("result = $result")
} 

Lorsque vous exécutez le programme, la sortie sera:

résultat = vrai
résultat = faux

Dans le programme ci-dessus, a or b au lieu de a.or(b) , et a and b au lieu de a.and(b) est utilisé. Cela a été possible car ces deux fonctions prennent en charge la notation infixe.


Comment créer une fonction avec la notation infixe?

Vous pouvez effectuer un appel de fonction dans Kotlin en utilisant la notation infixe si la fonction

  • est unfonction membre(ou unfonction d’extension).
  • n’a qu’un seul paramètre.
  • est marqué par infix mot-clé.

Exemple: fonction définie par l’utilisateur avec notation infixe

 class Structure() {

    infix fun createPyramid(rows: Int) {
        var k = 0
        for (i in 1..rows) {
            k = 0
            for (space in 1..rows-i) {
                print("  ")
            }
            while (k != 2*i-1) {
                print("* ")
                ++k
            }
            println()
        }
    }
}

fun main(args: Array<String>) {
    val p = Structure()
    p createPyramid 4       // p.createPyramid(4)
} 

Lorsque vous exécutez le programme, la sortie sera:

       * 
    * * * 
  * * * * * 
* * * * * * *  

Ici, createPyramid() est une fonction d’infixe qui crée une structure pyramidale. C’est une fonction membre de la classe Structure , prend un seul paramètre de type Int , et commence par le mot-clé infix 

Entrée / sortie de base Kotlin

Sortie Kotlin

Vous pouvez utiliser println() et print() fonctions pour envoyer la sortie à la sortie standard (écran). Prenons un exemple:

 fun main(args : Array<String>) {
    println("Kotlin is interesting.")
} 

Lorsque vous exécutez le programme, la sortie sera:

Kotlin est intéressant.

Ici, println() renvoie la chaîne (entre guillemets).


Différence entre println () et print ()

  •  print() – imprime la chaîne à l’intérieur des guillemets.
  •  println() – imprime la chaîne à l’intérieur des guillemets similaire comme print() fonction. Ensuite, le curseur se déplace au début de la ligne suivante.

Lorsque vous utilisez println() fonction, il appelle System.out.println() fonctionner en interne. ( System.out.println() est utilisé pour imprimer la sortie à l’écran en Java).

Si vous utilisez IntelliJ IDEA, placez le curseur de votre souris à côté de println et allez à Navigate  >  Declaration (Raccourci:Ctrl + B. Pour Mac:Cmd + B), cela ouvrira Console.kt (fichier de déclaration). Tu peux voir ça println() la fonction appelle en interne System.out.println() .

De même, lorsque vous utilisez print() fonction, il appelle System.out.print() fonction.


Exemple 1: print () et println ()

 fun main(args : Array<String>) {
    println("1. println ");
    println("2. println ");

    print("1. print ");
    print("2. print");
} 

Lorsque vous exécutez le programme, la sortie sera:

1. println
2. println
1. imprimer 2. imprimer

Exemple 2: Variables et littéraux d’impression

 fun main(args : Array<String>) {
    val score = 12.3

    println("score")
    println("$score")
    println("score = $score")
    println("${score + score}")
    println(12.3)
} 

Lorsque vous exécutez le programme, la sortie sera:

But
12,3
score = 12,3
24,6
12,3

Entrée Kotlin

Dans cette section, vous apprendrez à recevoir les commentaires de l’utilisateur.

Pour lire une ligne de chaîne dans Kotlin, vous pouvez utiliser readline() fonction.


Exemple 3: chaîne d’impression saisie par l’utilisateur

 fun main(args: Array<String>) {
    print("Enter text: ")

    val stringInput = readLine()!!
    println("You entered: $stringInput")
} 

Lorsque vous exécutez le programme, la sortie sera:

Entrez le texte: Hmm, intéressant!
Vous avez entré: Hmm, intéressant!

Il est possible de prendre l’entrée sous forme de chaîne en utilisant readLine() et convertissez-le en valeurs d’un autre type de données (comme Int ) explicitement.


Si vous souhaitez saisir d’autres types de données, vous pouvez utiliser Scanner objet.

Pour cela, vous devez importer Scanner classe de la bibliothèque standard Java en utilisant:

 import java.util.Scanner
 

Ensuite, vous devez créer Scanner  objet de cette classe.

 val reader = Scanner(System.`in`)
 

Maintenant lelecteurobjet est utilisé pour prendre les entrées de l’utilisateur.


Exemple 4: Obtenir une entrée entière de l’utilisateur

 import java.util.Scanner

fun main(args: Array<String>) {

    // Creates an instance which takes input from standard input (keyboard)
    val reader = Scanner(System.`in`)
    print("Enter a number: ")

    // nextInt() reads the next integer from the keyboard
    var integer:Int = reader.nextInt()

    println("You entered: $integer")
} 

Lorsque vous exécutez le programme, la sortie sera:

Entrez un nombre: -12
Tu es entré: -12

Ici, reader objet de Scanner la classe est créée. Puis le nextInt() La méthode est appelée qui prend une entrée entière de l’utilisateur qui est stockée dans la variableentier.


Obtenir Long ,  Float ,  double et Boolean entrée de l’utilisateur, vous pouvez utiliser nextLong() ,  nextFloat() ,  nextDouble() et nextBoolean() 

Variables C # et types de données (primitifs)

Une variable est un nom symbolique donné à un emplacement mémoire. Les variables sont utilisées pour stocker des données dans un programme informatique.


Comment déclarer des variables en C #?

Voici un exemple pour déclarer une variable en C #.

âge int;

Dans cet exemple, une variableâgede type int (integer) est déclaré et ne peut stocker que des valeurs entières.

Nous pouvons attribuer une valeur à la variable plus tard dans notre programme comme ceci:

âge int;
... ... ...
âge = 24;

Cependant, la variable peut également être initialisée à une certaine valeur lors de la déclaration. Par exemple,

âge int = 24;

Ici, une variableâgede type int est déclaré et initialisé à 24 en même temps.

Comme il s’agit d’une variable, nous pouvons également modifier la valeur des variables. Par exemple,

âge int = 24;
âge = 35 ans;

Ici, la valeur deâgepasse de 24 à 35.


Les variables en C # doivent être déclarées avant de pouvoir être utilisées. Cela signifie que le nom et le type de variable doivent être connus avant de pouvoir leur attribuer une valeur. C’est pourquoi C # est appelé un langage à typage statique.

Une fois déclaré, le type de données d’une variable ne peut pas être modifié dans une portée. Une portée peut être considérée comme un bloc de code où la variable est visible ou disponible à l’utilisation. Si vous ne comprenez pas la déclaration précédente, ne vous inquiétez pas, nous en apprendrons davantage sur les champs d’application dans les chapitres suivants.

Pour l’instant, rappelez-vous, nous ne pouvons pas faire ce qui suit en C #:

âge int;
âge = 24;
... ... ...
l'âge du flotteur;

Variables implicitement typées

Alternativement en C #, on peut déclarer une variable sans connaître son type en utilisant var mot-clé. Ces variables sont appeléesvariables locales typées implicitement.

Variables déclarées avec var Le mot clé doit être initialisé au moment de la déclaration.

valeur var = 5;

Le compilateur détermine le type de variable à partir de la valeur attribuée à la variable. Dans l’exemple ci-dessus,valeurest de type int . Cela équivaut à:

valeur int;
valeur = 5;

Vous pouvez en savoir plus sur les variables locales typées implicitement.


Règles de nommage des variables en C #

Il y a certaines règles que nous devons suivre pour nommer une variable. Les règles pour nommer une variable en C # sont:

  1. Le nom de la variable ne peut contenir que des lettres (majuscules et minuscules), des traits de soulignement (_) et des chiffres.
  2. Le nom de la variable doit commencer par une lettre, un trait de soulignement ou un symbole @. Par exemple,
    Règles de dénomination des variables en C #
    Noms de variables Remarques
    Nom Valide
    sujet101 Valide
    _âge Valide (meilleure pratique pour nommer les variables de membre privé)
    @Pause Valide (utilisé si nom est un mot-clé réservé)
    101subjet Non valide (commence par un chiffre)
    votre nom Valide
    votre nom Non valide (contient des espaces)
  3. C # est sensible à la casse. Ça veut direâgeetÂgefait référence à 2 variables différentes.
  4. Un nom de variable ne doit pas être un mot clé C #. Par exemple, if ,  for ,  using ne peut pas être un nom de variable. Nous discuterons plus en détail des mots-clés C # dans le prochain tutoriel.

Meilleures pratiques pour nommer une variable

  1. Choisissez un nom de variable qui a du sens. Par exemple,Nom, âge, matièrea plus de sens quen, uneets.
  2. Utilisationaffaire de chameaunotation (commence par une lettre minuscule) pour nommer les variables locales. Par exemple,nombre d’étudiants, âge, etc.
  3. UtilisationPascalCaseouAffaire de chameau(commence par une lettre majuscule) pour nommer les variables membres publiques. Par exemple,Prénom, Prix, etc.
  4. Utilisez un tiret bas (_) suivi deaffaire de chameaunotation pour nommer les variables de membre privé. Par exemple,_solde bancaire, _adresse e-mail, etc.

Vous pouvez en savoir plus sur les conventions de dénomination en C # ici.

Ne vous inquiétez pas des variables membres publiques et privées. Nous en apprendrons davantage sur eux dans les chapitres suivants.


Types de données primitifs C #

Les variables en C # sont généralement classées en deux types:Types de valeuretTypes de référence. Dans ce didacticiel, nous discuterons des types de données primitifs (simples) qui sont une sous-classe des types Value.

Les types de référence seront traités dans les didacticiels ultérieurs. Cependant, si vous souhaitez en savoir plus sur les types de variables, visitez Types et variables C # (documentation officielle C #).

Booléen (booléen)

  • Le type de données booléen a deux valeurs possibles: true ou false 
  • Valeur par défaut:  false 
  • Les variables booléennes sont généralement utilisées pour vérifier des conditions telles que dansdéclarations if, boucles, etc.

Par exemple:

 using System;
namespace DataType
{
    class BooleanExample
    {
        public static void Main(string[] args)
        {
            bool isValid = true;
            Console.WriteLine(isValid);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

Vrai

Signé intégral

Ces types de données contiennent des valeurs entières (positives et négatives). Sur le nombre total de bits disponibles, un bit est utilisé pour le signe.

1. sbyte

  • Taille: 8 bits
  • Intervalle: -128 à 127.
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class SByteExample
    {
        public static void Main(string[] args)
        {
            sbyte level = 23;
            Console.WriteLine(level);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

23

Essayez d’attribuer des valeurs hors plage, c’est-à-dire inférieures à -128 ou supérieures à 127 et voyez ce qui se passe.


2. court

  • Taille: 16 bits
  • Intervalle: -32 768 à 32 767
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class ShortExample
    {
        public static void Main(string[] args)
        {
            short value = -1109;
            Console.WriteLine(value);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

-1109

3. int

  • Taille: 32 bits
  • Intervalle: -231 à 231-1
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class IntExample
    {
        public static void Main(string[] args)
        {
            int score = 51092;
            Console.WriteLine(score);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

51092

4. long

  • Taille: 64 bits
  • Intervalle: -263 à 263-1
  • Valeur par défaut:  0L [L à la fin représente que la valeur est de type long]

Par exemple:

 using System;
namespace DataType
{
    class LongExample
    {
        public static void Main(string[] args)
        {
            long range = -7091821871L;
            Console.WriteLine(range);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

-7091821871

Intégrale non signée

Ces types de données ne contiennent que des valeurs égales ou supérieures à 0. Nous utilisons généralement ces types de données pour stocker des valeurs lorsque nous sommes sûrs que nous n’aurons pas de valeurs négatives.

1. octet

  • Taille: 8 bits
  • Intervalle: 0 à 255.
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class ByteExample
    {
        public static void Main(string[] args)
        {
            byte age = 62;
            Console.WriteLine(level);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

62

2. ushort

  • Taille: 16 bits
  • Intervalle: 0 à 65 535
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class UShortExample
    {
        public static void Main(string[] args)
        {
            ushort value = 42019;
            Console.WriteLine(value);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

42019

3. uint

  • Taille: 32 bits
  • Intervalle: 0 à 232-1
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class UIntExample
    {
        public static void Main(string[] args)
        {
            uint totalScore = 1151092;
            Console.WriteLine(totalScore);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

1151092

4. ulong

  • Taille: 64 bits
  • Intervalle: 0 à 264-1
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class ULongExample
    {
        public static void Main(string[] args)
        {
            ulong range = 17091821871L;
            Console.WriteLine(range);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

17091821871

Point flottant

Ces types de données contiennent des valeurs à virgule flottante, c’est-à-dire des nombres contenant des valeurs décimales. Par exemple, 12,36, -92,17, etc.

1. flotter

  • Type à virgule flottante simple précision
  • Taille: 32 bits
  • Intervalle: 1,5 × 10−45 à 3,4 × 1038
  • Valeur par défaut: 0.0F [F à la fin représente que la valeur est de type float]

Par exemple:

 using System;
namespace DataType
{
    class FloatExample
    {
        public static void Main(string[] args)
        {
            float number = 43.27F;
            Console.WriteLine(number);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

43.27

2. double

  • Type à virgule flottante double précision. Quelle est la différence entre la virgule flottante simple et double précision?
  • Taille: 64 bits
  • Intervalle: 5,0 × 10−324 à 1,7 × 10308
  • Valeur par défaut: 0.0D [D à la fin représente que la valeur est de type double]

Par exemple:

 using System;
namespace DataType
{
    class DoubleExample
    {
        public static void Main(string[] args)
        {
            double value = -11092.53D;
            Console.WriteLine(value);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

-11092.53

Caractère (char)

  • Il représente un caractère Unicode 16 bits.
  • Taille: 16 bits
  • Valeur par défaut: ‘\0’
  • Intervalle: U + 0000 (‘\ u0000’) à U + FFFF (‘\ uffff’)

Par exemple:   

 using System;
namespace DataType
{
    class CharExample
    {
        public static void Main(string[] args)
        {
            char ch1 ='\u0042';
            char ch2 = 'x';
            Console.WriteLine(ch1);
            Console.WriteLine(ch2);
        }
    }
}
 

Lorsque nous exécutons le programme, la sortie sera:

B
X

La valeur unicode de 'B' est '\u0042' , d’où l’impressionch1va imprimer 'B' .


Décimal

  • Le type décimal a plus de précision et une plage plus petite que les types à virgule flottante (double et float). Il convient donc aux calculs monétaires.
  • Taille: 128 bits
  • Valeur par défaut: 0.0M [M à la fin représente que la valeur est de type décimal]
  • Intervalle: (-7,9 x 1028 à 7,9 x 1028) / (100 à 28)

Par exemple:   

 using System;
namespace DataType
{
    class DecimalExample
    {
        public static void Main(string[] args)
        {
         decimal bankBalance = 53005.25M;
            Console.WriteLine(bankBalance);
        }
    }
}
 

Lorsque nous exécutons le programme, la sortie sera:

53005.25

Le suffixe M ou m doit être ajouté à la fin sinon la valeur sera traitée comme un double et une erreur sera générée.


Littéraux C #

Regardons la déclaration suivante:

nombre int = 41;

Ici,

  •  int est un type de données
  • nombreest une variable et
  •  41 est un littéral

Les littéraux sont des valeurs fixes qui apparaissent dans le programme. Ils ne nécessitent aucun calcul. Par exemple, 5 ,  false ,  'w' sont des littéraux qui apparaissent directement dans un programme sans aucun calcul.


Littéraux booléens

  • true et false sont les littéraux booléens disponibles.
  • Ils sont utilisés pour initialiser des variables booléennes.

Par exemple:

booléen isValid = true;
booléen isPresent = false;

Littéraux entiers

  • Les littéraux entiers sont utilisés pour initialiser les variables de types de données entiers, c’est-à-dire sbyte ,  short ,  int ,  long ,  byte ,  ushort ,  uint et ulong .
  • Si un littéral entier se termine par L ou l , il est de type long. Pour une utilisation optimale L (ne pas l ).
    valeur longue1 = 4200910L;
    valeur longue2 = -10928190L;
  • Si un littéral entier commence par un 0x , il représente une valeur hexadécimale. Les nombres sans préfixe sont traités comme des valeurs décimales. Les représentations octales et binaires ne sont pas autorisées en C #.
    int decimalValue = 25;
    int hexValue = 0x11c; // valeur décimale 284

Littéraux à virgule flottante

  • Les littéraux à virgule flottante sont utilisés pour initialiser les variables des types de données float et double.
  • Si un littéral à virgule flottante se termine par un suffixe f ou F , il est de type float. De même, s’il se termine par d ou D , il est de type double. Si aucun des suffixes n’est présent, il est de type double pardéfaut.
  • Ces littéraux contiennent e ou E lorsqu’ils sont exprimés en notation scientifique.
    nombre double = 24,67; // double par défaut
    valeur flottante = -12,29F;
    double ScientificNotation = 6,21e2; // équivalent à 6,21 x 102 soit 621

Littéraux de caractères et de chaînes

  • Les caractères littéraux sont utilisés pour initialiser les variables des types de données char.
  • Les caractères littéraux sont placés entre guillemets simples. Par exemple, 'x' ,  'p' , etc.
  • Ils peuvent être représentés sous forme de caractère, de séquence d’échappement hexadécimale, de représentation unicode ou de valeurs intégrales converties en char.
    char ch1 = 'R'; // caractère
    char ch2 = '\ x0072'; // hexadécimal
    char ch3 = '\ u0059'; // unicode
    char ch4 = (char) 107; // casté à partir d'un entier
  • Les littéraux de chaîne sont la collection de littéraux de caractères.
  • Ils sont placés entre guillemets. Par exemple,« Bonjour », « Programmation facile », etc.
    string firstName = "Richard";
    string lastName = "Feynman";
  • C # prend également en charge les caractères de séquence d’échappement tels que:
     

    Personnage Sens
     \'  Simple citation
     \"  Double citation
     \\  Barre oblique inverse
     \n  Nouvelle ligne
     \r  Retour chariot
     \t  Onglet horizontal
     \a  Alerte
     \b 

    Programme Kotlin pour trier ArrayList d’objets personnalisés par propriété

    Exemple: Trier ArrayList d’objets personnalisés par propriété

     import java.util.*
    
    fun main(args: Array<String>) {
    
        val list = ArrayList<CustomObject>()
        list.add(CustomObject("Z"))
        list.add(CustomObject("A"))
        list.add(CustomObject("B"))
        list.add(CustomObject("X"))
        list.add(CustomObject("Aa"))
    
        var sortedList = list.sortedWith(compareBy({ it.customProperty }))
    
        for (obj in sortedList) {
            println(obj.customProperty)
        }
    }
    
    public class CustomObject(val customProperty: String) {
    } 

    Lorsque vous exécutez le programme, la sortie sera:

    UNE
    Aa
    B
    X
    Z

    Dans le programme ci-dessus, nous avons défini un CustomObject classe avec un String propriété,customProperty.

    dans le main() méthode, nous avons créé une liste de tableaux d’objets personnalisésliste, initialisé avec 5 objets.

    Pour trier la liste avec la propriété, nous utilisonslistede sortedWith() méthode. le sortedWith() la méthode prend un comparateur compareBy 

    Augmentation du C ++ ()

    rise () Prototype

    int augmenter (int sig);

    La fonction rise appelle le gestionnaire de signal. Si aucune fonction définie par l’utilisateur n’est définie pour la gestion du signal, l’implémentation définit si le signal sera ignoré ou si le gestionnaire par défaut sera appelé.

    Il est défini dansEn tête de fichier.

    Paramètres rise ()

    sig: Le signal à envoyer pour traitement. Il peut prendre l’une des valeurs suivantes:

    • SIGABRT
    • SIGFPE
    • SIGILL
    • SIGINT
    • SIGSEGV
    • SIGTERM

    rise () Valeur de retour

    En cas de succès, il renvoie zéro et en cas d’échec, une valeur différente de zéro est renvoyée.

    Exemple: Fonctionnement de la fonction rise ()

     #include <iostream>
    #include <csignal>

    using namespace std;

    sig_atomic_t sig_value = 0;

    void handler(int sig)
    {
    sig_value = sig;
    }

    int main()
    {
    signal(SIGABRT, handler);
    cout << "Before signal handler is called" << endl;
    cout << "Signal = " << sig_value << endl;
    raise(SIGABRT);
    cout << "After signal handler is called" << endl;
    cout << "Signal = " << sig_value << endl;

    return 0;
    }
     

    C Allocation de mémoire dynamique

    Comme vous le savez, un tableau est une collection d’un nombre fixe de valeurs. Une fois la taille d’un tableau déclarée, vous ne pouvez pas la modifier.

    Parfois, la taille du tableau que vous avez déclaré peut être insuffisante. Pour résoudre ce problème, vous pouvez allouer de la mémoire manuellement pendant l’exécution. C’est ce qu’on appelle l’allocation de mémoire dynamique dans la programmation C.

    Pour allouer dynamiquement de la mémoire, les fonctions de la bibliothèque sont malloc() ,  calloc() ,  realloc() et free() sont utilisés. Ces fonctions sont définies dans le <stdlib.h> En tête de fichier.


    C malloc ()

    Le nom «malloc» signifie allocation de mémoire.

    le malloc() La fonction réserve un bloc de mémoire du nombre d’octets spécifié. Et, il renvoie un pointeur de void qui peuvent être convertis en pointeurs de toute forme.


    Syntaxe de malloc ()

     ptr = (castType*) malloc(size); 

    Exemple

     ptr = (float*) malloc(100 * sizeof(float)); 

    L’instruction ci-dessus alloue 400 octets de mémoire. C’est parce que la taille de float est de 4 octets. Et, le pointeurptrcontient l’adresse du premier octet de la mémoire allouée.

    L’expression se traduit par un NULL pointeur si la mémoire ne peut pas être allouée.


    C calloc ()

    Le nom «calloc» signifie allocation contiguë.

    le malloc() alloue de la mémoire et laisse la mémoire non initialisée. Tandis que le calloc() La fonction alloue de la mémoire et initialise tous les bits à zéro.


    Syntaxe de calloc ()

     ptr = (castType*)calloc(n, size); 

    Exemple:

     ptr = (float*) calloc(25, sizeof(float)); 

    L’instruction ci-dessus alloue un espace contigu en mémoire pour 25 éléments de type float .


    C libre ()

    Mémoire allouée dynamiquement créée avec soit calloc() ou malloc() ne se libère pas d’eux-mêmes. Vous devez utiliser explicitement free() pour libérer l’espace.


    Syntaxe de free ()

     free(ptr); 

    Cette instruction libère l’espace alloué dans la mémoire pointé par ptr .


    Exemple 1: malloc () et free ()

     // Program to calculate the sum of n numbers entered by the user
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
        int n, i, *ptr, sum = 0;
    
        printf("Enter number of elements: ");
        scanf("%d", &n);
    
        ptr = (int*) malloc(n * sizeof(int));
     
        // if memory cannot be allocated
        if(ptr == NULL)                     
        {
            printf("Error! memory not allocated.");
            exit(0);
        }
    
        printf("Enter elements: ");
        for(i = 0; i < n; ++i)
        {
            scanf("%d", ptr + i);
            sum += *(ptr + i);
        }
    
        printf("Sum = %d", sum);
      
        // deallocating the memory
        free(ptr);
    
        return 0;
    } 
    

    Ici, nous avons alloué dynamiquement la mémoire pournnombre de int .


    Exemple 2: calloc () et free ()

     // Program to calculate the sum of n numbers entered by the user
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
        int n, i, *ptr, sum = 0;
        printf("Enter number of elements: ");
        scanf("%d", &n);
    
        ptr = (int*) calloc(n, sizeof(int));
        if(ptr == NULL)
        {
            printf("Error! memory not allocated.");
            exit(0);
        }
    
        printf("Enter elements: ");
        for(i = 0; i < n; ++i)
        {
            scanf("%d", ptr + i);
            sum += *(ptr + i);
        }
    
        printf("Sum = %d", sum);
        free(ptr);
        return 0;
    }
     

    Réallocation C ()

    Si la mémoire allouée dynamiquement est insuffisante ou plus que nécessaire, vous pouvez modifier la taille de la mémoire précédemment allouée à l’aide du realloc() fonction.


    Syntaxe de realloc ()

     ptr = realloc(ptr, x); 

    Ici,ptrest réaffecté avec une nouvelle tailleX.


    Exemple 3: realloc ()

     #include <stdio.h>
    #include <stdlib.h>

    int main()
    {
    int *ptr, i , n1, n2;
    printf("Enter size: ");
    scanf("%d", &n1);

    ptr = (int*) malloc(n1 * sizeof(int));

    printf("Addresses of previously allocated memory: ");
    for(i = 0; i < n1; ++i)
    printf("%u\n",ptr + i);

    printf("\nEnter the new size: ");
    scanf("%d", &n2);

    // rellocating the memory
    ptr = realloc(ptr, n2 * sizeof(int));

    printf("Addresses of newly allocated memory: ");
    for(i = 0; i < n2; ++i)
    printf("%u\n", ptr + i);

    free(ptr);

    return 0;
    }