Quoi de plus avec ou c. Opérateurs de relation et opérateurs logiques. Opérations pour l'informatique entier

Depuis dans l'article précédent, j'ai d'abord utilisé une opération logique, je vous dirai ce qu'ils sont, combien et comment ils les utilisent.

En C ++, il existe trois opérations logiques:

1. Opération logique et &&, nous sommes déjà connus;
2. Opération logique ou || ;
3. Opération logique NE. ! ou déni logique.

Les opérations logiques forment une condition complexe (composite) à partir de plusieurs conditions simples (deux ou plus). Ces opérations simplifient la structure code de logiciel plusieurs fois. Oui, vous pouvez le faire sans eux, mais le nombre d'IFOS augmente plusieurs fois, en fonction de la condition. Le tableau suivant décrit brièvement toutes les opérations logiques dans le langage de programmation C ++ pour créer des conditions logiques.

Maintenant, vous devriez comprendre la différence entre exploitation logique Et une opération logique ou ne pas être confondues à l'avenir. Il est temps de se familiariser avec le type de données Bool -Logique. Ce type Les données peuvent prendre deux valeurs: vraie (vérité) et false. La condition vérifiée dans les opérateurs de sélection a un type de données BOOL. Considérez le principe de fonctionnement du programme suivant et tout sera compris avec toutes ces opérations logiques.

// or_and_not.cpp: Spécifie le point d'entrée de l'application de la console. #Include "stdafx.h" #include Utilisation de Namespace STD; Int Main (int Argc, char * argv) (BOOL A1 \u003d TRUE, A2 \u003d FAUX; // Annonce des variables logiques BOOL A3 \u003d TRUE, A4 \u003d FALSE; COUT;<< "Tablica istinnosti log operacii &&" << endl; cout << "true && false: " << (a1 && a2) << endl // логическое И << "false && true: " << (a2 && a1) << endl << "true && true: " << (a1 && a3) << endl << "false && false: " << (a2 && a4) << endl; cout << "Tablica istinnosti log operacii ||" << endl; cout << "true || false: " << (a1 || a2) << endl // логическое ИЛИ << "false || true: " << (a2 || a1) << endl << "true || true: " << (a1 || a3) << endl << "false || false: " << (a2 || a4) << endl; cout << "Tablica istinnosti log operacii !" << endl; cout << "!true: " << (! a1) << endl // логическое НЕ << "!false: "<< (! a2) << endl; system("pause"); return 0; }

Rangées 9 et 10 Vous devez être compris, car le type de variables est initialisé ici. Bool . Et chaque variable est attribuée à la valeur Vrai ou faux. Commençant par 9ème rangée Et finition 20-y.L'utilisation d'opérations logiques est affichée. Le résultat du programme (voir la figure 1).

Tablica istinnosti journal operacii && true && faux: 0 faux && true: 0 true && true: 1 faux && faux: 0 tablica istinnosti log operacii || VRAI || Faux: 1 faux || Vrai: 1 vrai || Vrai: 1 faux || FAUX: 0 Tablica Istinnosti Log Operacii! ! TRUE: 0! FAUX: 1 Pour continuer, appuyez sur n'importe quelle touche. . .

Figure 1 - Opérations logiques C ++

Probablement, vous avez une question, "Quels sont ces testeurs et parts?". S'il y a une question, vous devez répondre. Je réponds: "Nolik est une représentation de la valeur logique des faux (mensonges), mais les unités sont une vraie logique (vérité)." Expliquez brièvement quelques moments. Condition composée en utilisant logique ET Vrai que lorsque les deux conditions simples sont vraies. Dans tous les autres cas, la condition composite est fausse. Condition composée en utilisant logique ou faussement uniquement lorsque de fausses conditions simples. Dans tous les autres cas, la condition composite est vraie. Déni logique NE PAS est une opération unaire et ne combine pas deux conditions, contrairement aux opérations logiques ET et OU ALORSqui sont des opérations binaires. Le déni logique vous permet de retourner le sens de la condition que, dans certains cas, il est très pratique. La condition avec un déni logique est vraie si la même condition est fausse sans négatif, et inversement.

Dans le texte dans n'importe quel langage naturel, vous pouvez sélectionner quatre éléments principaux: symboles, mots, phrases et suggestions. Le langage algorithmique contient également de tels éléments, seuls les mots sont appelés lexemes (structures élémentaires), phrases - expressions, offres - opérateurs. Les lexemes sont formés à partir de symboles, d'expressions de lexemes et de symboles, des opérateurs des expressions et des symboles Lexing (Fig. 1.1)

Figure. 1.1. La composition de la langue algorithmique

Ainsi, les éléments de la langue algorithmique sont les suivants:

1) Langue alphabet C ++, qui inclut

- lettres majuscules et minuscules en lettres latines et un signe de soulignement;

- nombre arabe de 0 à 9;

- Signes spéciaux "(), | () + - /% *. \\ ':; &?<>=!#^

- Symboles aveugles (écart, symbole d'onglets, symboles de transition sur une nouvelle chaîne).

2) Les lexemes de langue sont formés à partir de caractères:

— Identificateurs - noms des objets de programme C. Les lettres latines, les chiffres et un signe de soulignement peuvent être utilisés dans l'identifiant. Les lettres majuscules et minuscules diffèrent, par exemple, PROG1, PROG1 et PROG1 sont trois identifiants différents. Le premier caractère devrait être la lettre ou le soulignement (mais pas une figure). Les espaces dans des identificateurs ne sont pas autorisés.

— Clé Les mots (réservés) sont des mots qui ont une valeur spéciale pour le compilateur. Ils ne peuvent pas être utilisés comme identifiants.

- Les signes d'opérations sont un ou plusieurs caractères qui déterminent l'action sur les opérandes. Les opérations sont divisées en unary, binaire et Ternar dans le nombre d'opérandes participant à cette opération.

— Constantes- Ce sont des valeurs immuables. Il y a des constantes entier, réelles, symboliques et de cordes. Le compilateur met en évidence la constante en tant que lexeme (design élémentaire) et le concerne l'un des types en fonction de son apparence.

— Diviseurs - Supports, points, icônes spatiales de virgule.

Constantes en C ++

Constant - Il s'agit d'un lexeme représentant une image d'une valeur numérique, une chaîne ou une valeur symbolique fixe.

Les constantes sont divisées en 5 groupes:

- réel (point flottant);

- énumérés;

- symbolique;

- Chaîne.

Le compilateur sélectionne un Lex et le concerne à un groupe particulier, puis à l'intérieur du groupe à un type spécifique sur sa forme d'enregistrement dans le texte du programme et de la valeur numérique.

Les constantes peuvent être décimales, octal et hexadécimales. La constante décimale est définie comme une séquence de chiffres décimaux, qui ne commence pas à 0, si ce n'est pas 0 (exemples: 8, 0, 192345). La constante octale est une constante qui commence toujours avec 0. Dans 0 suit les nombres octals (exemples: 016 - Valeur décimale 14, 01). Les constantes hexagonales sont une séquence de nombres hexadécimaux qui précèdent les caractères 0x ou 0x (exemples: 0A, 0x00f).

En fonction de la valeur de toute la constante, le compilateur présentera de différentes manières à la mémoire de l'ordinateur (c'est-à-dire que le compilateur apparaîtra la constante de type de données correspondante).

Les constantes réelles ont une autre forme de présentation interne dans la mémoire de l'ordinateur. Le compilateur reconnaît de telles constantes en fonction de leur esprit. Les vraies constantes peuvent avoir deux formes de forme: avec un point fixe et un point flottant. Point fixe Vue constante: [Figures]. [Figures] (Exemples: 5.7, 0,0001, 41.). Vue d'une constante de point flottante: [Figures] [.] [Figures] E | e [+ | -] [Figures ] (Exemples: 0.5E5, .11E-5, 5E3). Dans l'enregistrement de constantes réelles, une partie entière ou une partie fractionnelle, soit un point décimal, soit un signe d'exponentielles avec un indicateur de la mesure peut être abaissée.

Les constantes énumérées sont entrées à l'aide du mot clé ENUM. Celles-ci sont des constantes entières communes uniques et pratiques à utiliser la désignation sont attribuées. Exemples: Enum (un \u003d 1, deux \u003d 2, trois \u003d 3, quatre \u003d 4);

enum (zéro, un, deux, trois) - Si dans la définition des constantes énumérées omet des signes \u003d et des valeurs numériques, les valeurs seront attribuées à la valeur par défaut. Dans ce cas, l'identifiant à gauche recevra une valeur de 0, et chaque subséquenter augmentera par 1.

enum (dix \u003d 10, trois \u003d 3, quatre, cinq, six);

enum (dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi);

Les constantes symboliques sont un ou deux caractères enfermés dans des apostrophes. Les constantes symboliques constituées d'un symbole ont un type de char et occuper un octet en mémoire, les constantes de caractères constituées de deux caractères ont le type INT et occupent deux octets. Les séquences commençant par le signe \\ sont appelées gestionnaires, ils sont utilisés:

- Pour représenter des caractères qui n'ont pas d'affichage graphique, par exemple:

\\ A - Beep,

\\ B - renvoyer une étape,

\\ n - traduction de la ligne,

\\ T - onglet horizontal.

- Pour la présentation des personnages: \\, ',? , "(\\\\, \\ ', \\ ?, \\").

- Pour représenter des caractères avec des codes hexadécimaux ou octals (\\ 073, \\ 0xf5).

La constante de chaîne est une séquence de caractères enfermée dans des guillemets. À l'intérieur des rangées, vous pouvez également utiliser des caractères de contrôle. Par exemple: "\\ nnoving string",

"\\ N \\" algorithmiques langages d'une programmation de haut niveau \\ "".

Types de données en C ++

Les données sont affichées dans le programme du monde entier. L'objectif du programme est de traiter les données. Données différents types sont stockés et traités de différentes manières. Type de données détermine:

1) une représentation interne des données dans la mémoire de l'ordinateur;

2) beaucoup de valeurs pouvant prendre des valeurs de ce type;

3) Opérations et fonctions pouvant être appliquées aux données de ce type.

En fonction des exigences du travail, le programmateur sélectionne le type d'objets de programme. Les types de C ++ peuvent être divisés en simples et composites. Les types simples incluent des types caractérisés par une seule valeur. En C ++, 6 types de données simples sont définis:

Il existe 4 spécificateurs de type spécifiant la représentation interne et la gamme de types standard

court (court)

long (long)

signé (signe)

non signé (non signé)

Un typeint.

Les valeurs de ce type sont des entiers.

La taille de type INT n'est pas déterminée par la norme, mais dépend de l'ordinateur et du compilateur. Pour un processeur 16 bits, 2 octets y sont attribués, pour 32 bits - 4 octets.

Si le spécificateur court est debout avant INT, alors 2 octets sont donnés au nombre, et si le spécificateur long, puis 4 octets. Du nombre d'affectés à l'objet de mémoire, les nombreuses valeurs valides pouvant recevoir un objet dépend:

bref int - occupe 2 octets, donc, a une plage -32768 .. + 32767;

long int - rangs 4 octets, donc, a une plage -2 147 483 648 .. + 2 147 483 647

Le type Int coïncide avec le type INT court sur des PC 16 bits et avec de long int Le PC 32 bits.

Les modificateurs signés et non signés affectent également l'ensemble des valeurs admissibles que l'objet peut prendre:

sans signé bref int - occupe 2 octets, par conséquent, a une gamme de 0 ..65536;

non signé Long Int - Classes 4 octets, par conséquent, a une gamme de 0 .. + 4 294 967 295.

Un typecarboniser.

Les valeurs de ce type sont les éléments de l'ensemble de caractères commandé final. Chaque caractère est mis en conformité avec le numéro appelé code de symbole. Sous la taille de l'octet de type 1 de type 1 est donné. Le type de caractère peut être utilisé avec des spécificateurs signés et non signés. Dans ces types de caractères signés, vous pouvez stocker des valeurs dans la plage de -128 à 127. Lors de l'utilisation du type de caractères non signé, les valeurs peuvent être comprises entre 0 et 255. Le code ASCII est utilisé pour le codage ( Code standard américain FOE Interchange international). Les symboles avec des codes de 0 à 31 sont des services et ont une valeur indépendante uniquement dans les déclarations d'E / S.

Les valeurs de type de caractère sont également utilisées pour stocker des numéros à partir des plages spécifiées.

Un typewcharnt.

Conçu pour fonctionner avec un ensemble de caractères pour le codage qui ne suffit pas de 1 octet, tel que Unicode. La taille de ce type, en règle générale correspond au type de short. Les constantes de cordes de ce type sont enregistrées avec le préfixe L: L "String n ° 1".

Un typebool

Le type Bool s'appelle logique. Ses valeurs peuvent prendre des valeurs réelles et fausses. La forme interne de représentation FALSE est 0, toute autre valeur est interprétée comme vraie.

Types de points flottants.

La représentation interne du nombre réel est composée de 2 parties: la mantissa et l'ordre. Dans IBM-Compatible PC, la taille du type de flotteur est occupée par 4 octets, dont une décharge est prise sous le signe de la MANTUSSA, 8 décharges sous la commande et 24 - sous la mantissie.

Les valeurs des types de double occupation 8 octets, 11 et 52 décharges sont déchargées sous la commande et la mantissa, respectivement. La longueur de la mantissa détermine la précision du nombre et la longueur de sa plage.

S'il existe un long spécificateur devant le nom de type double, les octets sont donnés sous la magnitude.

Un typeannuler.

Les types principaux incluent également le type de vide de nombreuses valeurs de ce type - vide.

Variables

La variable en C ++ est une zone de mémoire nommée dans laquelle les données sont stockées. La variable a un nom et une valeur. Le nom sert à faire référence à la zone de mémoire dans laquelle la valeur est stockée. Avant utilisation, toute variable doit être décrite. Exemples:

Vue générale de la description de la description:

[Classe de mémoire] Nom de type [Initializer];

La classe mémoire peut prendre des valeurs: auto, externe, statique, registre. La classe mémoire détermine la durée de vie et la portée de la variable. Si la classe mémoire n'est pas explicite explicitement, le compilateur détermine son sur la base du contexte publicitaire. Le temps de vie peut être permanent - pendant l'exécution du programme ou temporaire - pendant le bloc. Portée - Partie du texte du programme à partir desquels nous assumons l'accès habituel à la variable. Habituellement, le champ d'application de la visibilité coïncide avec la zone d'action. De plus, le cas lorsqu'il y a une variable dans le bloc interne avec le même nom.

Const - indique que cette variable ne peut pas être modifiée (nommée constante).

Lorsque vous décrivez, vous pouvez affecter une variable de valeur initiale (initialisation).

Cours de mémoire:

variable locale auto-cuiromatic. Le spécificateur automatique ne peut être spécifié que lors de la détermination des objets de bloc, par exemple dans la fonction corporelle. Cette mémoire variable est libérée à l'entrée de l'appareil et est libérée lors de la sortie. En dehors du bloc, ces variables n'existent pas.

externe est une variable globale, c'est dans un autre lieu du programme (dans un autre fichier ou partage dans le texte). Utilisé pour créer des variables disponibles dans tous les fichiers de programme.

static est une variable statique, elle n'existe que dans les limites du fichier où la variable est définie.

le registre est similaire à Auto, mais la mémoire est attribuée dans les registres de processeur. S'il n'y a pas de telle possibilité, les variables sont traitées comme auto.

Int a; // Variable globale vide () (INT B; // Variable locale externe int x; // variable x est défini ailleurs statique Int C; // Variable statique locale A \u003d 1; // Affectation d'une variable globale Int A; / / Variable locale AA \u003d 2; // attribution d'une variable locale :: a \u003d 3; // attribution d'une variable globale) int x \u003d 4; // Définition et initialisation x

Dans l'exemple, la variable A est déterminée en dehors de tous les blocs. La zone d'action de la variable A est l'ensemble du programme, à l'exception de ces lignes où la variable locale A est utilisée. Variables B et C - Local, la zone de leur visibilité est un bloc. Living Lifetime: la mémoire sous B est relâchée lors de la saisie du bloc (car par défaut, la classe de mémoire automatique) est libérée lors de la sortie. Une variable avec (statique) existe pendant que le programme fonctionne.

Si, lors de la détermination de la valeur initiale, les variables ne sont pas spécifiées explicitement, puis les variables globales et statiques de compilateur réinitialisent. Les variables automatiques ne sont pas initialisées.

Le nom de la variable doit être unique dans son domaine d'action.

La description de la variable peut être complétée ou comme une annonce, ou en tant que définition. L'AD contient des informations sur la classe de mémoire et le type de variable, la définition avec ces informations donne une indication pour allouer la mémoire. Dans l'exemple d'extern int x; - Annonce et les autres définitions.

SI / + Signes d'opérations

Les signes d'opérations assurent la formation d'expressions. Les expressions sont composées d'opérandes, de signes d'opérations et de crochets. Chaque opérande est à son tour l'expression ou le cas privé d'expressions est une constante ou une variable.

Opérations uniques

&	obtenir l'adresse de l'opérande
*	Appel à l'adresse (portée)
—	unarys moins, change le signe de l'opérande arithmétique
~	inverser discontinu du code binaire interne d'opérande entier (déni bitwise)
!	déni logique (non). En tant que valeurs logiques, 0 - Faux et non 0 - Vérité, le déni 0 sera 1, le déni de tout numéro non nul sera 0.
++	Augmenter d'une: opération de préfixe - Augmente l'opérande à son utilisation, l'opération Postfix augmente l'opérande après son utilisation. int a \u003d (m ++) + n; // a \u003d 4, m \u003d 2, n \u003d 2 int b \u003d m + (++ n); // a \u003d 3, m \u003d 1, n \u003d 3 3
— —	réduire par unité: opération de préfixe - Réduit les opérandes avant utilisation, l'opération Postfix réduit l'opérande après son utilisation.
taille de	calcul de la taille (en octets) pour l'objet de ce type, qui a un opérande il a deux formes taille d'expression taille de (flotteur) // 4 tailleof (1.0) // 8, car les constantes réelles par défaut ont un type de double

Opérations binaires.

Additif:

Multiplicatif:

Opérations de décalage (définies uniquement pour les opérandes entier).

Format d'expression avec opération de décalage:

operand_shel opérande opérande opérande

Opérations du chiffre:

Opérations de comparaison: le résultat est vrai (pas 0) ou faux (0)

Opérations binaires logiques:

Opérations d'affectation

Etc.

Format des opérations Simple Affectation:

operand1 \u003d operand2

La valeur de gaspillage de gauche (valeur L) est une expression qui répond à une partie de la mémoire, c'est-à-dire qu'elle peut y être ajoutée. Ce nom est arrivé à partir de l'opération d'affectation, car la partie gauche de l'opération d'affectation est déterminée que le fonctionnement de l'opération sera entré dans quelle zone de mémoire. La variable est un cas particulier d'une expression des lésives.

Fonctionnement conditionnel.

Contrairement aux opérations uniques et binaires, il utilise trois opérandes.

Expression1? Expression2: expression3;

Le premier est la valeur de l'expression1. S'il est vrai, la valeur de l'expression2 est calculée, ce qui devient le résultat. Si, lors du calcul de l'expression1, il s'avère 0, puis la valeur d'expression est prise en conséquence.

Par example:

x.<0 ? -x: x ; //вычисляется абсолютное значение x.

Exploitation de type de type explicite (conversion).

Il y a deux formes: canonique et fonctionnelle:

1) (nom) Opérande

2) Nom de type_ (opérande)

(int) a // forme canonique

int (a) // forme fonctionnelle

Expressions

Des constantes, des variables, des séparateurs et des opérations d'exploitation peuvent concevoir des expressions. Chaque expression est une règle de calcul d'une nouvelle valeur. Si l'expression génère un nombre entier ou un nombre réel, il est appelé arithmétique. Une paire d'expressions arithmétiques, combinées à une opération de comparaison, est appelée attitude. Si le ratio a une valeur non nulle, il est vrai, sinon, faux.

Priorités des opérations dans les expressions

Rang	Exploitation
1	() -> .
2	! ~ - ++ - & * (type) Taille de type ()
3	* /% (binaire multiplicatif)
	+ - (additif binaire)
5	<< >\u003e (SHIFT BONNétique)
6	< > <= >\u003d (Relation)
7	\u003d\u003d! \u003d (Relation)
8	& (liaison conjonction "et")
9	^ (Figure à l'exclusion "ou")
10	| (Diagraphie »ou»)
11	&& (conjonction "et")
12	|| (disjonction "ou")
13	?: (Opération conditionnelle)
14	= *= /= %= -= &= ^= |= <<= >\u003e \u003d (opération d'affectation)
15	, (opération des virgules)

Dernière mise à jour: 06/19/2017

Un ensemble d'opérations séparé est des expressions conditionnelles. Ces opérations renvoient une valeur logique, c'est-à-dire la valeur de type BOOL: TRUE, si l'expression est vraiment, et false, si l'expression est fausse. Ces opérations comprennent la comparaison et les opérations logiques.

Opérations de comparaison

Dans les opérations de comparaison, deux opérandes sont comparés et la valeur de type BOOL est vraie, si l'expression est vraie et false, si l'expression est incorrecte.

Comparez deux opérandes pour l'égalité. S'ils sont égaux, l'opération renvoie true, sinon égale, puis FALSE est renvoyé:

B; // Faux

Comparez deux opérandes et retourne true si les opérandes ne sont pas égaux et de faux, s'ils sont égaux.

Int A \u003d 10; int b \u003d 4; Bool c \u003d a! \u003d B; // vrai bool d \u003d a! \u003d 10; // Faux

Opération "moins que". Retourne true si le premier opérande est inférieur au second, et faux, si le premier opérande est supérieur à la seconde:

Int A \u003d 10; int b \u003d 4; Bool c \u003d a< b; // false

Opération "plus que". Comparez deux opérandes et retournez true si le premier opérande est plus que le second, sinon retourne faux:

Int A \u003d 10; int b \u003d 4; Bool c \u003d a\u003e b; // vrai bool d \u003d a\u003e 25; // Faux

Opération "moins ou égale." Compare deux opérandes et retourne vrai si le premier opérande est inférieur ou égal à la seconde. Sinon retourne faux.

Int A \u003d 10; int b \u003d 4; Bool c \u003d a<= b; // false bool d = a <= 25; // true

Opération "supérieure ou égale." Comparez deux opérandes et retourne true si le premier opérande est supérieur ou égal au second, sinon False est renvoyé:

Int A \u003d 10; int b \u003d 4; Bool c \u003d a\u003e \u003d b; // vrai bool d \u003d a\u003e \u003d 25; // Faux

Exploitation<, > <=, >\u003d avoir une plus grande priorité que \u003d\u003d et! \u003d.

Opérations logiques

Également dans les opérateurs logiques définis C #, qui renvoient également la valeur du type BOOL. En tant qu'opérands, ils prennent la valeur du bool. En règle générale, appliquer aux relations et combiner plusieurs opérations de comparaison.

Fonctionnement de l'ajout logique ou logique ou. Retourne vrai si au moins un des opérandes revient vrai.

Bool x1 \u003d (5\u003e 6) | (quatre< 6); // 5 > 6 - faux, 4< 6 - true, поэтому возвращается true bool x2 = (5 > 6) | (4\u003e 6); // 5\u003e 6 - FAUX, 4\u003e

Fonctionnement de la multiplication logique ou de la logique I. Renvoie true si les deux opérandes sont simultanément égaux à true.

Bool x1 \u003d (5\u003e 6) & (4< 6); // 5 > 6 - faux, 4< 6 - true, поэтому возвращается false bool x2 = (5 < 6) & (4 < 6); // 5 < 6 - true, 4 < 6 - true, поэтому возвращается true

Fonctionnement de l'ajout logique. Retourne vrai si au moins un des opérandes revient vrai.

Bool x1 \u003d (5\u003e 6) || (quatre< 6); // 5 > 6 - faux, 4< 6 - true, поэтому возвращается true bool x2 = (5 > 6) || (4\u003e 6); // 5\u003e 6 - FAUX, 4\u003e 6 \u200b\u200b- FAUX, SO FAUX RETOURS

Exploitation de la multiplication logique. Retourne vrai si les deux opérandes sont vraies en même temps.

Bool x1 \u003d (5\u003e 6) && (4< 6); // 5 > 6 - faux, 4< 6 - true, поэтому возвращается false bool x2 = (5 < 6) && (4 < 6); // 5 < 6 - true, 4 < 6 - true, поэтому возвращается true

Exploitation du déni logique. Il est effectué au-dessus d'un opérande et retourne vrai si l'opérande est faux. Si l'opérande est vrai, l'opération retourne faux:

Bool a \u003d vrai; Bool b \u003d! A; // Faux

Opération à l'exclusion ou. Retourne vrai si le premier ou le deuxième opérande (mais pas en même temps) est vrai, sinon retourne faux

Bool x5 \u003d (5\u003e 6) ^ (4< 6); // 5 > 6 - faux, 4< 6 - true, поэтому возвращается true bool x6 = (50 > 6) ^ (4 / 2 < 3); // 50 > 6 - vrai, 4/2< 3 - true, поэтому возвращается false

Nous avons ici deux paires d'opérations | et || (ainsi que & & &&) effectuent des actions similaires, mais elles ne sont pas équivalentes.

Dans l'expression z \u003d x | y; Les deux valeurs seront calculées - x et y.

Dans l'expression z \u003d x || y; Premièrement, la valeur de X sera d'abord calculée et si elle est vraie, le calcul de la valeur de Y n'a pas de sens, car dans tous les cas, Z sera égal à vrai. La valeur de y sera calculée uniquement si le x est égal à faux

La même chose s'applique à Paire d'opérations & / &&. Dans l'expression Z \u003d X, les deux valeurs seront calculées - x et y.

Dans l'expression z \u003d x & sera d'abord calculé x, et s'il est égal à faux, le calcul de la valeur de y n'a pas de sens, car dans tous les cas, Z sera égal à faux. La valeur y ne sera calculée que si x est vrai

Par conséquent, Opérations || et && sont plus pratiques dans les calculs, car il vous permet de réduire le temps nécessaire pour calculer la valeur de l'expression et augmenter ainsi la productivité. Et opérations | et et sont plus adaptés à l'exécution des opérations de soumissionnaire sur les chiffres.

Opérateurs de relation et opérateurs logiques

Dans la notation opérateur de la relation et opérateur logique terme rapports signifie la relation qui peut exister entre deux valeurs et le terme logique - la relation entre les valeurs logiques de "vérité" et "mensonge". Et puisque les opérateurs de la relation donnent des résultats vrais ou fausses, ils sont souvent utilisés avec des opérateurs logiques. C'est pour cette raison qu'ils sont considérés conjointement.

Vous trouverez ci-dessous les opérateurs de relations:

Le logique comprend les opérateurs ci-dessous:

Le résultat de l'exécution de l'opérateur de la relation ou de l'opérateur logique est la valeur logique du type BOOL.

En général, les objets peuvent être comparés à l'égalité ou à l'inégalité en utilisant les opérateurs de relations \u003d\u003d et! \u003d. Et les opérateurs de comparaison, \u003d ne peuvent être utilisés que vers les types de données prenant en charge le ratio de commande. Par conséquent, les opérateurs relationnels peuvent être appliqués à tous les types de données numériques. Mais les valeurs de type Bool ne peuvent être comparées qu'à l'égalité ou à l'inégalité, car les valeurs vraies (vraies) et false (FALS) ne sont pas commandées. Par exemple, la comparaison de véritables\u003e False in C # n'a pas de sens.

Considérons un exemple de programme démontrant l'utilisation des relations et des opérateurs logiques:

Utiliser le système; en utilisant System.Collections.Genic; En utilisant system.linq; En utilisant system.text; Espace de noms ConsoleApplication1 (String args (chaîne vide D \u003d 10, F \u003d 12; BOOL VAR1 \u003d TRUE, VAR2 \u003d FALSE; SI (DF) Console.WRITRION ("D\u003e F"); // Comparaison de variables Var1 et Var2 Si (Var1 & Var2) console.writeine \u200b\u200b("Ce texte ne va pas désactiver"); si (! (Var1 & var2)) console.writeline ("! (Var1 & var2) \u003d true"); si (var1 | var2) console.write ("var1 | var2 \u003d true"); si (var1 ^ var2) console.writeline ("var1 ^ var2 \u003d true"); console.readline ();))))

Les opérateurs logiques de C # effectuent les opérations logiques les plus courantes. Néanmoins, il existe un certain nombre d'opérations effectuées par les règles de la logique formelle. Ces opérations logiques peuvent être construites à l'aide des opérateurs logiques pris en charge dans C #. Par conséquent, en C #, il existe un tel ensemble d'opérateurs logiques, qui suffit à construire presque toutes les opérations logiques, y compris les implications. Amplication - Il s'agit d'une opération binaire, qui est une valeur fausse uniquement si son opérande gauche a un sens véritable, et le bon est faux. (L'opération d'implication reflète le principe suivant: la vérité ne peut impliquer un mensonge.)

L'opération d'implication peut être construite sur la base d'une combinaison d'opérateurs logiques! et |

Opérateurs logiques raccourcis

C # a aussi spécial, raccourcissement, options pour les opérateurs logiques et ou, conçus pour obtenir un code plus efficace. Expliquons dans les exemples suivants d'opérations logiques. Si le premier opérande d'une opération logique et a une valeur fausse (FALSE), son résultat aura une valeur fausse quelle que soit la valeur du deuxième opérande. Si le premier opérande d'une opération logique ou a une valeur vraie (VRAI), son résultat aura une valeur réelle indépendamment de la valeur du deuxième opérande. En raison du fait que la valeur du deuxième opérande dans ces opérations n'a pas besoin d'être calculée, Économise du temps et augmente l'efficacité du code.

Une opération logique raccourcie et est effectuée en utilisant opérateur &&et une opération logique abrégée ou - avec opérateur ||. Ces opérateurs logiques raccourcis correspondent aux opérateurs logiques ordinaires et et |. La seule différence entre l'opérateur logique raccourci de l'habituel réside dans le fait que son deuxième opérande n'est calculé que si nécessaire.

Toute expression de la langue consiste en des opérandes (variables, constantes, etc.) reliées par les signes d'opérations. Le signe de fonctionnement est un symbole ou un groupe de caractères qui signalent le compilateur sur la nécessité d'effectuer certaines actions arithmétiques, logiques ou autres.

Les opérations sont effectuées dans une séquence stricte. La valeur qui détermine le droit préventif d'effectuer une opération particulière est appelée priorité. Dans l'onglet. 2 Disposé diverses opérations de la langue SI (C). Leurs priorités pour chaque groupe sont les mêmes (les groupes sont mis en évidence en couleur). Le plus grand avantage que le groupe d'opérations correspondant est utilisé, plus il est élevé dans la table. La procédure d'exécution des opérations peut être réglementée à l'aide de parenthèses.

Tableau 2 - Opérations

Signe d'exploitation	But de l'opération
	Fonction d'appel
	Allocation de l'élément du tableau
	Sélection de l'élément d'entrée
	Sélection de l'élément d'entrée
	Déni logique
	Déni numérique
	Changement de signe
	Égalité par unité
	Réduction par unité
	Prendre l'adresse
	Appel à l'adresse
	Type de conversion (c'est-à-dire (flotteur) a)
	Détermination de la taille en octets
	Multiplication
	Détermination de l'équilibre
	Une addition
	Soustraction
	Décalage à gauche
	Passer à droite
	Moins que
	Moins ou égal
	Plus que
	Plus ou égal
	Prêt logique "et"
	Chiffre excluant "ou"
	Prêt logique "ou"
	Logique "et"
	Logique "ou"
	Opération conditionnelle (Ternar)
	Mission
+=, - =, *=, /=, %=, <<=, >>=, &=, |=, ^=	Opérations binaires (par exemple, A * \u003d B (C'est-à-dire A \u003d A * B), etc.)
	Operation virgule

Opérateur en Si (C)

Pour exclure la confusion dans les concepts d'exploitation "et" opérateur ", nous notons que l'opérateur est la plus petite unité exécutable du programme. Les opérateurs d'expression sont distingués, dont l'action consiste à calculer les expressions spécifiées (par exemple: a \u003d péché (B) + c; j ++;), opérateurs de publicité, opérateurs composites, opérateurs vides, opérateurs d'étiquettes, cycle, etc. . Pour faire référence à la fin de l'opérateur dans la langue SI (C), un point est utilisé. En ce qui concerne l'opérateur composite (ou le bloc), qui est un ensemble d'opérateurs logiquement associés placés entre l'ouverture (() et la fermeture ()) des supports bouclés («Supports de l'opérateur»), le point d'une virgule n'est pas placé. Notez que le bloc diffère de l'opérateur composite par la présence de définitions dans le corps du bloc.

Caractéristiques des opérations principales de la langue SI (C)

Nous caractérisent les opérations de base de la langue SI (C).

Opération d'affectation

Premièrement, considérons l'un d'entre eux - l'opération d'affectation (\u003d). Expression de type

attribue la valeur de la variable x de la variable y. L'opération "\u003d" est autorisée à utiliser plusieurs fois dans une expression, par exemple:

x \u003d y \u003d z \u003d 100;

Distinguer les opérations uniques et binaires. Dans la première partie, un opérande et le deuxième - deux. Commençons leur examen des opérations liées au premier des groupes traditionnels suivants:

Opérations arithmétiques.

Relations logiques et relations de relations.

Opérations avec des bits.

Les opérations arithmétiques sont définies par les symboles suivants (tableau 2): +, -, *, /,%. Le dernier ne peut pas être appliqué à une variable de type réel. Par example:

a \u003d b + c;
x \u003d y - z;
R \u003d t * v;
S \u003d k / l;
P \u003d q% w;

Opérations logiques

Les opérations de relation logique sont définies par les symboles suivants (voir tableau 2): && ("et"), || ("OU ALORS"), ! ("Pas"),\u003e,\u003e \u003d,<, <= , = = (равно), != (не равно). Традиционно эти операции должны давать одно из двух значений: истину или ложь. В языке СИ (C)принято следующее правило: истина - это любое ненулевое значение; ложь - это нулевое значение. Выражения, использующие логические операции и операции отношения, возвращают 0 для ложного значения и 1 для истинного. Ниже приводится таблица истинности для логических операций.

Les opérations de bits peuvent être appliquées sur des variables qui ont des types int, des types de caractères, ainsi que de leurs variantes (par exemple, AT). Ils ne peuvent pas être appliqués à des types de flotteurs variables, doubles, vides (ou plus types complexes). Ces opérations sont définies par les symboles suivants: ~ (déni de capatal),<< (сдвиг влево), >\u003e (passer à droite), & (Bonnet "et"), ^ (bits excluant "ou"), | (Chiffre "ou").

Exemples: Si A \u003d 0000 1111 et B \u003d 1000 1000, puis

~ A \u003d 1111 0000,
UNE.<< 1 = 0001 1110,
A \u003e\u003e 1 \u003d 0000 0111,
A & B \u003d 0000 1000,
a ^ b \u003d 1000 0111,
un | B \u003d 1000 1111.

La langue prévoit deux opérations incrémentées non traditionnelles (++) et décrément (-). Ils sont conçus pour augmenter et diminuer la valeur de l'opérande. Fonctionnement ++ et - peuvent être enregistrés à la fois devant l'opérande et après. Dans le premier cas (++ N ou -N), la valeur de l'opérande (n) change avant son utilisation dans l'expression appropriée et dans la seconde (N ++ ou N--) - après son utilisation. Considérez les deux rangées suivantes du programme:

a \u003d B + C ++;
A1 \u003d B1 +++ C1;

Supposons que b \u003d b1 \u003d 2, c \u003d c1 \u003d 4. Ensuite, après avoir effectué des opérations: A \u003d 6, B \u003d 2, C \u003d 5, A1 \u003d 7, B1 \u003d 2, C1 \u003d 5.

Les expressions avec une autre opération ternie non traditionnelle ou conditionnelle sont généralisées. Dans la formule

y \u003d A, si x n'est pas zéro (c'est-à-dire vrai), et y \u003d b, si x est zéro (faux). Expression suivante

y \u003d (a\u003e b)? UN B;

vous permet d'attribuer une variable dans la valeur d'une plus grande variable (A ou B), c'est-à-dire y \u003d max (a, b).

Une autre distinction de la langue est que l'expression de la forme a \u003d A + 5; peut être écrit sous une autre forme: A + \u003d 5;. Au lieu d'un signe +, vous pouvez utiliser les symboles d'autres opérations binaires (voir tableau 2).

Autres opérations de table. 2 seront décrits dans les paragraphes suivants.

Les cycles sont organisés pour effectuer certains opérateurs ou groupes d'opérateurs un certain nombre de fois. Dans la langue SI (C), trois opérateurs de cycle: pour, tandis que. Le premier d'entre eux est officiellement écrit, sous la forme suivante:

pour (expression_1; expression_2; expression_3) Body_tsikla

Le corps de cycle est un opérateur, soit plusieurs opérateurs enfermés dans des supports bouclés (...) (après le point de bloc avec une virgule de virgule n'est pas placé). Dans les expressions 1, 2, 3 apparaît une variable spéciale appelée contrôle. Par sa valeur, la nécessité du cycle de répétition ou de la sortie est établie.

Expression_1 attribue la valeur initiale de la variable de contrôle, l'expression_s le modifie à chaque étape, et l'expression_2 vérifie s'il a atteint la valeur limite qui établit la nécessité de quitter le cycle.

pour (i \u003d 1; je< 10; i++)

pour (сh \u003d "a"; ch! \u003d "p";) scanf ("% c", & ch);

/ * Le cycle sera exécuté jusqu'au clavier

le symbole "p" * /

L'une des trois expressions du cycle pour le cycle peut être absente, cependant, le point d'une virgule devrait rester. Ainsi, pour (;;) (...) est un cycle infini, à partir desquels vous pouvez sortir uniquement d'une autre manière.

Dans la langue SI (c), la règle suivante est prise. Toute expression avec une opération d'affectation enfermée entre parenthèses est égale à attribuer. Par exemple, l'expression (A \u003d 7 + 2) est de 9. Après cela, vous pouvez écrire une autre expression, par exemple: ((A \u003d 7 + 2)<10), которое в данном случае будет всегда давать истинное значение. Следующая конструкция:

((Sh \u003d getch ()) \u003d\u003d "i")

vous permet d'entrer la valeur de la variable CH et de donner le résultat vrai uniquement lorsque la valeur entrée est la lettre "I". Entre-arrière, vous pouvez enregistrer plusieurs formules constituant une expression complexe. À ces fins, l'opération de la virgule est utilisée. Les formules seront calculées de gauche à droite et toute expression prendra la valeur de la dernière formule calculée. Par exemple, s'il y a deux variables de type caractère, puis expression

z \u003d (x \u003d y, y \u003d getch ());

définit les actions suivantes: La valeur de la variable Y est attribuée à la variable X; Un symbole du clavier est introduit et attribué à la variable Y; z obtient la valeur de la variable y. Les supports sont nécessaires ici, car l'opération de la virgule a une priorité plus faible que l'opération d'affectation enregistrée après la variable z. L'opération de virgule est largement utilisée pour créer les expressions de cycle et vous permet de modifier simultanément les valeurs de plusieurs variables de contrôle.

Les structures investies sont autorisées, c'est-à-dire Dans le corps de certains cycle, d'autres pour les opérateurs peuvent survenir.

La déclaration tandis que la déclaration est formellement écrite sous cette forme:

tandis que (expression) body_tsikla

L'expression entre parenthèses peut prendre une valeur non nulle (vraie) ou zéro (false). Si c'est vraiment, le corps du cycle est effectué et l'expression est à nouveau calculée. Si l'expression est fausse, alors le cycle tandis que le cycle se termine.

La déclaration Do-While est formellement écrite comme suit:

faire (body_cyklla) alors que (expression);

La principale différence entre le moment et le fait - tandis que les cycles sont que le corps du cycle DO - tandis que le cycle est effectué au moins une fois. Le corps du cycle sera effectué jusqu'à ce que l'expression entre parenthèses fasse une fausse valeur. S'il est faux en entrant dans le cycle, son corps est effectué exactement une fois.

La nidification de certains cycles à d'autres est autorisée, c'est-à-dire Dans le corps de tout cycle, les opérateurs pour, tandis qu'elles peuvent apparaître.

Dans le corps du cycle, une nouvelle pause et des opérateurs de maintien peuvent être utilisés. L'opérateur de pause fournit une sortie immédiate du cycle, l'opérateur de poursuite provoque la résiliation du prochain et le début de la prochaine itération.

Opérateurs de transition conditionnels et inconditionnels

Pour organiser des transitions conditionnelles et inconditionnelles dans le programme SI (C), les opérateurs sont utilisés: si - sinon, commutateur et goto. Le premier est écrit comme suit:

si (check_linking) opérateur_1; Autre opérateur_2;

Si la condition entre parenthèses prend la valeur réelle, l'opérateur_1 est effectué si le faux opérateur_2. Si au lieu d'une fois que vous devez effectuer plusieurs opérateurs, ils sont des accolades bouclées. Dans la déclaration de si, le mot d'autre peut être absent.

Dans la déclaration IF - else directement après que les mots-clés Si et bien doivent suivre d'autres opérateurs. Si au moins l'un d'entre eux est un opérateur si, il est appelé investi. Selon l'accord adopté dans l'Accord SI (C), le mot qui fait toujours référence à la plus proche si précédent.

L'opérateur d'interrupteur vous permet de choisir l'une des différentes alternatives. Il est écrit sous la forme formelle suivante:

commutateur (expression)

case Constanta_1: Opérateurs_1;

case Constanta_2: Opérateurs_2;

........ ........

par défaut: opérateurs_default;

Ici, la valeur d'une expression entière entre parenthèses est calculée (on l'appelle parfois le sélecteur) et il est comparé à toutes les constantes (expressions constantes). Toutes les constantes doivent être différentes. Lors de la correspondance, une version appropriée des opérateurs (un ou plusieurs opérateurs) est exécutée. Une option avec un mot clé par défaut est implémentée si aucun autre approché (le mot défaut peut être manquant). Si la valeur par défaut est absente et que tous les résultats de la comparaison sont négatifs, aucune option n'est effectuée.

Pour arrêter les chèques de suivi après un choix réussi de certaines options, l'opérateur de pause est utilisé, offrant une sortie immédiate à partir du commutateur.

Conceptions de commutation investies.

Considérez les règles d'exécution d'une transition inconditionnelle pouvant être soumise sous la forme suivante:

Étiquette goto;

L'étiquette est un identifiant après lequel le côlon est livré. L'opérateur GOTO indique que le programme doit être poursuivi à partir de l'opérateur, avant l'enregistrement de l'étiquette. L'étiquette peut être mise en face de tout opérateur de la fonction où l'opérateur goto correspond à elle. Cela ne devrait pas être annoncé.

Turbo Debugger prend pleinement en charge la syntaxe des expressions des expressions SI (C). L'expression consiste en un mélange d'opérations, de chaînes, de variables