34

--- Ръководство за C# --- Струни

По отношение на редовното програмиране, string низов тип данние един от най-важните в C#. Този тип дефинира и поддържа символни низове. В редица други езици за програмиране низът е масив от знаци. А в C# низовете са обекти. Следователно типът низ е един от референтните типове.

Редова конструкция

Най-лесният начин за конструиране на символен низ е да използвате низов литерал. Например в следния ред код на променливата за препратка към низ str е присвоена препратка към литерал на низ:

String str = "Примерен низ";

В този случай променливата str се инициализира с последователността от символи "Примерен низ". Обект от тип string може също да бъде създаден от масив от тип char. Например:

Char chararray = ("e", "x", "a", "m", "p", "l", "e"); низ str = нов низ (chararray);

След като бъде създаден обект от тип string, той може да се използва навсякъде, където се изисква низ от цитиран текст.

Устойчивост на низа

Колкото и да е странно, съдържанието на обект от тип string не може да бъде модифицирано. Това означава, че веднъж създадена последователност от символи, тя не може да бъде променяна. Но това ограничение допринася за по-ефективно прилагане на символни низове. Следователно този, на пръв поглед, очевиден недостатък всъщност се превръща в предимство. Така че, ако имате нужда от низ като вариант на съществуващ низ, тогава за тази цел трябва да създадете нов низ, съдържащ всички необходими промени. И тъй като неизползваните низови обекти автоматично се събират в "боклук", тогава дори не е нужно да се тревожите за съдбата на ненужните низове.

Все пак трябва да се подчертае, че референтните променливи на низ (т.е. обекти от тип string) подлежат на промяна и следователно могат да препращат към друг обект. Но съдържанието на самия низов обект не се променя, след като е бил създаден.

Помислете за пример:

Static void addNewString() ( низ s = "Това е моят щрих"; s = "Това е нов щрих"; )

Нека компилираме приложението и заредим полученото събрание в помощната програма ildasm.exe. Фигурата показва CIL кода, който ще бъде генериран за метода void addNewString():

Забележете множеството извиквания на кода на операцията ldstr (зареждане на низ). Този код на операция ldstr в CIL кара нов обект на низ да бъде зареден в управляваната купчина. В резултат на това предишният обект, който съдържаше стойността „Това е моят удар“, в крайна сметка ще бъде събран за боклук.

Работа със струни

В клас System.Stringпредоставен е набор от методи за определяне на дължината на символните данни, търсене на подниз в текущия низ, преобразуване на символи от Главна буквадо дъното и обратно и т.н. След това ще разгледаме този клас по-подробно.

Поле, индексатор и свойство на класа String

Класът String има дефинирано едно поле:

Публичен статичен низ само за четене Празен;

Полето Empty обозначава празен низ, т.е. низ, който не съдържа знаци. Това е различно от празна препратка към низ, която просто се прави към несъществуващ обект.

Освен това класът String дефинира единичен индексатор само за четене:

Обществено char this ( get; )

Този индексатор ви позволява да получите знака на посочения индекс. Индексирането на низове, подобно на масивите, започва от нула. Низовите обекти са постоянни и не се променят, така че има смисъл класът String да поддържа индексатор само за четене.

И накрая, класът String дефинира едно свойство само за четене:

Public int Length ( get; )

Свойството Length връща броя знаци в низ. Примерът по-долу показва използването на индексатор и свойството Length:

Използване на системата; клас Пример ( static void Main() ( string str = "Прост низ"; // Вземете дължината на низа и 6-ия знак в низа с помощта на индексатора Console.WriteLine("Дължината на низа е (0), 6-ият знак е "(1)"" , str.Length, str); ) )

Класови оператори на низове

Класът String претоварва следните два оператора: == и !=. Операторът == се използва за тестване на два символни низа за равенство. Когато операторът == се прилага към препратки към обекти, той обикновено проверява дали и двете препратки са към един и същ обект. И когато операторът == се прилага към обектни препратки от тип String, съдържанието на самите низове се сравнява за равенство. Същото важи и за оператора !=. Когато се прилага към обектни препратки от тип String, съдържанието на самите низове се сравнява за неравенство. В същото време други релационни оператори, включително =, сравняват препратките към обекти от тип String по същия начин, както към обекти от други типове. И за да проверите дали един низ е по-голям от друг, трябва да извикате метода Compare(), дефиниран в класа String.

Както ще стане ясно по-късно, много видове сравнения на символни низове използват културна информация. Но това не се отнася за операторите == и !=. В края на краищата те просто сравняват поредните стойности на знаците в низовете. (С други думи, те сравняват стойности на двоични знаци, които не са били модифицирани от културни норми, т.е. локали.) Следователно тези оператори извършват сравнения на низове по начин, нечувствителен към малки и големи букви и култура.

Методи на клас низове

Следващата таблица изброява някои от по-интересните методи от този клас, групирани по предназначение:

Струнни методи
Метод Структура и претоварени версии Предназначение
Сравнение на низове
Сравнете() public static int Compare(string strA, string strB)

Public static int Compare(string strA, string strB, bool ignoreCase)

Public static int Compare(string strA, string strB, StringComparison сравнение на тип)

Public static int Compare(string strA, string strB, bool ignoreCase, CultureInfo култура)

Статичен метод, сравнява низа strA с низа strB. Връща положително, ако strA е по-голямо от strB; отрицателно, ако strA е по-малко от strB; и нула, ако низовете strA и strB са равни. Сравнението е чувствително към малки и малки букви и културно чувствително.

Ако параметърът ignoreCase вземе булевовярно, сравнението не взема предвид разликите между главни и малки букви. В противен случай тези разлики се вземат предвид.

Параметърът сравнениеТип указва конкретния начин, по който низовете се сравняват. Класът CultureInfo е дефиниран в пространството на имената System.Globalization.
public static int Compare(string strA, int indexA, string strB, int indexB, int length)

Public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase)

Public static int Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison сравнение на типа)

Public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase, CultureInfo култура)

Сравнява части от низовете strA и strB. Сравнението започва с низовите елементи strA и strB и включва броя знаци, определени от параметъра за дължина. Методът връща положителна стойност, ако част от strA е по-голяма от част от strB; отрицателна стойност, ако част от strA е по-малка от част от strB; и нула, ако сравнените части на низовете strA и strB са равни. Сравнението е чувствително към малки и малки букви и културно чувствително.
compareOrdinal() public static int CompareOrdinal(string strA, string strB)

Public static int CompareOrdinal(string strA, int indexA, string strB, int indexB, int count)

Прави същото като метода Compare(), но без оглед на локалните настройки
Сравни с() public int CompareTo(стойност на обект)

Сравнява извикващия низ с низовото представяне на стойностния обект. Връща положителна стойност, ако извикващият низ е по-голям от стойността на низа; отрицателна стойност, ако извикващият низ е по-малък от низа със стойност; и нула, ако сравняваните низове са равни
public int CompareTo(string strB)

Сравнява извикващия низ със strB
Се равнява() публична замяна bool Equals(обект obj)

Връща булевото true, ако извикващият низ съдържа същата последователност от знаци като низовото представяне на obj. Извършва поредно сравнение, чувствително към малки и главни букви, но без културна чувствителност
public bool Equals (низова стойност)

Public bool Equals(низова стойност, StringComparison сравнение на тип)

Връща булевата стойност true, ако извикващият низ съдържа същата последователност от знаци като стойността на низа. Извършва се поредно сравнение, чувствително към малки и големи букви, но без културна чувствителност. Параметърът сравнениеТип дефинира специфичен начин за сравняване на низове
public static bool Equals(низ a, низ b)

Публичен статичен bool Equals(низ a, низ b, StringComparison сравнение на тип)

Връща boolean true, ако низ a съдържа същата последователност от знаци като низ b. Извършва се поредно сравнение, чувствително към малки и големи букви, но без културна чувствителност. Параметърът сравнениеТип дефинира специфичен начин за сравняване на низове
Конкатенация (свързване) на низове
Concat() публичен статичен низ Concat(низ str0, низ str1);

публичен статичен низ Concat(параметри стойности на низ);

 Комбинира отделни екземпляри на низ в един низ (конкатенация)
Търсене в низ
Съдържа() public bool Съдържа (низова стойност) Метод, който ви позволява да определите дали даден низ съдържа конкретен подниз (стойност)
Започва с() public bool StartsWith(низова стойност)

Public bool StartsWith(низова стойност, StringComparison сравнение на тип)

Връща булевото значение true, ако извикващият низ започва със стойностния подниз. В противен случай се връща булевата стойност false. Параметърът сравнениеТип указва как да се извърши търсенето.
Завършва със() public bool EndsWith(низова стойност)

Public bool EndsWith(низова стойност, StringComparison сравнение на тип)

Връща булевото значение true, ако извикващият низ завършва със стойностния подниз. В противен случай връща булевата стойност false. Параметърът сравнениеТип дефинира конкретен метод за търсене
Индекс на() public int IndexOf(char value)

Public int IndexOf(низова стойност)

Намира първото срещане на даден подниз или знак в низ. Ако знакът или поднизът, който търсите, не бъде намерен, тогава се връща -1.
public int IndexOf(char value, int startIndex)

Public int IndexOf(низова стойност, int startIndex)

Public int IndexOf(char value, int startIndex, int count)

Public int IndexOf(низова стойност, int startIndex, int count)

Връща индекса на първото появяване на стойността на знака или подниза в извикващия низ. Търсенето започва от елемента, определен в index startIndex, и обхваща броя на елементите, посочени от параметъра count (ако е зададен). Методът връща -1, ако търсеният символ или подниз не е намерен
LastIndexOf() Претоварените версии са подобни на метода IndexOf().

Същото като IndexOf, но намира последното срещане на знак или подниз вместо първото
IndexOfAny() public int IndexOfAny(char anyOf)

Public int IndexOfAny(char anyOf, int startIndex)

Public int IndexOfAny(char anyOf, int startIndex, int count)

Връща индекса на първото появяване на всеки знак в масива anyOf, намерен в извикващия низ. Търсенето започва от елемента, определен от index startIndex, и обхваща броя на елементите, посочени от параметъра count (ако има такъв). Методът връща -1, ако не бъде намерено съвпадение за някой от символите в масива anyOf. Търсенето се извършва по редовен начин
LastIndexOfAny Претоварените версии са подобни на метода IndexOfAny().

Връща индекса на последното появяване на всеки знак в масива anyOf, намерен в извикващия низ
Разделяне и конкатениране на низове
Сплит публичен низ Split (params char separator)

Разделяне на публичен низ (параметри char separator, int count)

Метод, който връща масив от низове с поднизовете, присъстващи в този екземпляр вътре, разделени един от друг с елементи от посочения char или масив от низове.

Първата форма на метода Split() разделя извикващия низ на съставните му части. Резултатът е масив, съдържащ поднизовете, извлечени от извикващия низ. Знаците, които ограничават тези поднизове, се предават в разделителния масив. Ако разделителният масив е празен или се отнася за празен низ, тогава като разделител на подниз се използва интервал. И във втората форма този методвръща броя на поднизовете, посочени от параметъра count.
public string Split (params char separator, StringSplitOptions options)

Разделяне на публичен низ (разделител на низове, опции за StringSplitOptions)

Разделяне на публичен низ (параметри разделител на знаци, int count, опции StringSplitOptions)

Разделяне на публичен низ (разделител на низове, int count, опции StringSplitOptions)

Първите две форми на метода Split() разделят извикващия низ на части и връщат масив, съдържащ поднизовете, получени от извикващия низ. Знаците, които разделят тези поднизове, се предават в разделителния масив. Ако масивът от разделители е празен, тогава като разделител се използва интервал. А в третата и четвъртата форма на този метод се връща броят на редовете, ограничен от параметъра count.

Но във всички форми параметърът за опции указва специфичен начин за обработка на празни низове, които се генерират, когато два разделителя са съседни. Изброяването на StringSplitOptions дефинира само две стойности: Нито едини RemoveEmptyEntries. Ако параметърът за опции е None, тогава празните низове се включват в крайния резултат от разделянето. оригинален низ. И ако параметърът опции е настроен на RemoveEmptyEntries, тогава празните низове се изключват от крайния резултат от разделянето на оригиналния низ.
Присъединяване() публичен статичен низ Join(разделител на низ, стойност на низ)

Обществен статичен низ Join(разделител на низ, стойност на низ, int startIndex, int count)

Създава нов низ чрез комбиниране на съдържанието на масив от низове.

Първата форма на метода Join() връща низ, състоящ се от конкатенирани поднизове, предадени в масива от стойности. Втората форма също връща низ, състоящ се от поднизовете, предадени в масива от стойности, но те са свързани с определен брой преброявания, започвайки от елемента от масива от стойности. И в двете форми всеки следващ ред е отделен от предишния ред с разделителен низ, определен от параметъра за разделител.
Линии за пълнене и подрязване
подстригване () публичен низ Trim()

Обществен низ Trim(params char trimChars)

Метод, който ви позволява да премахнете всички срещания на определен набор от знаци от началото и края на текущия низ.

Първата форма на метода Trim() премахва началните и крайните интервали от извикващия низ. И втората форма на този метод премахва водещите и завършващи срещания в извикващия низ от знаци от масива trimChars. И двете форми връщат резултантния низ.
PadLeft() публичен низ PadLeft(int totalWidth)

Обществен низ PadLeft(int totalWidth, char paddingChar)

Позволява ви да допълвате низа със знаци отляво.

Първата форма на метода PadLeft() въвежда интервали от лявата страна на извикващия низ, така че общата му дължина става равно на стойносттапараметърът totalWidth. Във втората форма на този метод символите, обозначени с параметъра paddingChar, се въвеждат от лявата страна на извикващия низ, така че общата му дължина да стане равна на стойността на параметъра totalWidth. И двете форми връщат резултантния низ. Ако стойността на параметъра totalWidth е по-малка от дължината на извикващия низ, тогава се връща копие на немодифицирания извикващ низ.
PadRight() Подобно на PadLeft()

Позволява ви да допълвате низа със знаци вдясно.
Вмъкване, изтриване и замяна на редове
вмъкване() public string Insert(int startIndex, string value)

Използва се за вмъкване на един низ в друг, където value е низът, който трябва да бъде вмъкнат в извикващия низ при индекс startIndex. Методът връща получения низ.
Премахване() публичен низ Remove(int startIndex)

Обществен низ Премахване (int startIndex, int count)

Използва се за премахване на част от низ. В първата форма на метода Remove() премахването се извършва, като се започне от мястото, посочено от index startIndex, и се продължи до края на низа. И във втората форма на този метод, броят знаци, посочени от параметъра count, се премахва от низа, започвайки от мястото, указано от индекса startIndex.
Замени() публичен низ Replace(char oldChar, char newChar)

Обществен низ Замяна (низ oldValue, низ newValue)

Използва се за замяна на част от низ. Първата форма на метода Replace() заменя всички срещания на oldChar в извикващия низ с newChar. И във втората форма на този метод всички срещания на низа oldValue в извикващия низ се заменят с низа newValue.
Смяна на регистъра
ToUpper() публичен низ ToUpper()

Записва всички букви в извикващия низ с главни букви.
Да понижи() публичен низ ToLower()

Прави всички букви в извикващия низ малки букви.
Получаване на подниз от низ
Подниз() публичен низ Подниз (int startIndex)

Обществен низ Подниз (int startIndex, int дължина)

В първата форма на метода Substring() поднизът се извлича от местоположението, указано от параметъра startIndex до края на извикващия низ. И във втората форма на този метод се извлича подниз, състоящ се от броя знаци, посочени от параметъра за дължина, започвайки от мястото, посочено от параметъра startIndex.

Следният пример на програма използва няколко от горните методи:

Използване на системата; използване на System.Collections.Generic; използване на System.Linq; използване на System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // Сравнете първите два низа string s1 = "това е низ"; низ s2 = "това е текст, това е низ"; if (String.CompareOrdinal (s1, s2) != 0) Console.WriteLine("Низовете s1 и s2 не са равни"); if (String.Compare(s1, 0, s2, 13, 10, true) == 0) Console.WriteLine( „Те обаче съдържат един и същ текст“); // Конкатенация на низ Console.WriteLine(String.Concat("\n" + "One, two ","three, four")); // Търсене в низ // Първо появяване на подниз if (s2. IndexOf("this") != -1) Console.WriteLine("Думата \"this\" беше намерена в реда, тя е "+ "на: (0) позиция", s2. IndexOf("this")); // Последно срещане на подниза if (s2.LastIndexOf("this") != -1) Console.WriteLine("Последното срещане на \"this\" е " + "в ( 0) позиция", s2.LastIndexOf("this" )); // Търсене от масива от знаци char myCh = ("S","x","t"); if (s2.IndexOfAny(myCh) != -1) Console.WriteLine("Един от знаците от масива ch "+" намерен в текущия текуща линия на позиция (0)", s2.IndexOfAny(myCh)); // Определяне дали низът започва с дадения подниз if (s2.StartsWith("this is text") == true) Console.WriteLine("Намерен е подниз!"); // Определете дали низът съдържа подниз // като използвате примера за определяне на низа на операционната система на потребителя myOS = Environment.OSVersion.ToString(); if (myOS.Contains("NT 5.1")) Console.WriteLine("Вашата ОС Windows система XP"); else if (myOS.Contains("NT 6.1")) Console.WriteLine("Вашият операционна система Windows 7"); Console.ReadLine(); ) ) )

Малко за сравнението на низове в C#

От всички операции за обработка на символен низ това е може би най-често извършваното сравнение на един низ с друг. Преди да разгледаме каквито и да било методи за сравнение на низове, трябва да се подчертае следното: сравнението на низове може да се направи в .NET Framework по два основни начина:

    Първо, сравнението може да отразява обичаите и нормите на определена културна среда, които често са културни настройки, които влизат в сила, когато програмата се изпълнява. Това е стандартно поведение за някои, макар и не всички, методи за сравнение.

    И второ, сравнението може да се извърши независимо от настройките на културната среда само по редовите стойности на символите, които съставят низа. Най-общо казано, нечувствителното към културата сравнение на низове използва лексикографски ред (и езикови характеристики), за да определи дали един низ е по-голям, по-малък или равен на друг низ. При порядково сравнение низовете просто се подреждат въз основа на немодифицираната стойност на всеки знак.

Поради разликите в начина, по който низовете се сравняват между културите и порядковите сравнения, както и последиците от всяко такова сравнение, силно препоръчваме да използвате най-добрите практики, предлагани в момента от Microsoft. В крайна сметка, изборът на грешен начин за сравняване на низове може да доведе до неправилна работа на програмата, когато тя работи в среда, различна от тази, в която е разработена.

Изборът как да се сравняват символни низове е много важно решение. Като общо правило и без изключение трябва да изберете културно чувствително сравнение на низове, ако е с цел показване на резултата на потребителя (например, за показване на поредица от низове, сортирани в лексикографски ред). Но ако низовете съдържат фиксирана информация, която не е предназначена да бъде модифицирана поради културни различия, като име на файл, ключова дума, адрес на уебсайт или стойност, свързана със сигурността, тогава трябва да изберете сравнение на пореден низ. Разбира се, спецификата на конкретното разработвано приложение ще диктува избора на подходящ начин за сравняване на символни низове.

Класът String предоставя различни методи за сравнение на низове, които са изброени в таблицата по-горе. Най-универсалният сред тях е методът Compare(). Позволява ви да сравнявате два низа изцяло или частично, чувствителни или нечувствителни към малки и главни букви, по начин на сравнение, определен от параметъра тип Сравнение на низове, както и културна информация, предоставена от параметъра тип КултурИнфо.

Тези претоварвания на метода Compare(), които не съдържат параметър от тип StringComparison, извършват чувствително към регистър и култура сравнение на символни низове. И в тези претоварени варианти, които не съдържат параметър от тип CultureInfo, информацията за културата се определя от текущата среда за изпълнение.

Типът StringComparison е изброяване, което дефинира стойностите, показани в таблицата по-долу. Използвайки тези стойности, можете да организирате сравнения на низове, които отговарят на нуждите на вашето приложение. Следователно добавянето на параметър тип StringComparison разширява възможностите на метода Compare() и други методи за сравнение като Equals(). Той също така дава възможност недвусмислено да се определи как низовете да се сравняват.

Поради разликите между културно чувствителните сравнения на низове и редните сравнения е важно да бъдете възможно най-точни в това отношение.

Стойности, дефинирани в StringComparison enum
Значение Описание
CurrentCulture Сравнението на низове се извършва с помощта на текущите настройки на културата
CurrentCultureIgnoreCase Сравнението на низове се извършва с помощта на текущите настройки на културата, но не е чувствително към главни и малки букви
InvariantCulture Сравнението на низове се извършва с помощта на неизменни, т.е. универсални данни за културната среда
InvariantCultureIgnoreCase Сравнението на низове се извършва с помощта на неизменни, т.е. универсални културни данни и нечувствителни към малки и главни букви
Пореден номер Сравнението на низове се извършва с помощта на поредните стойности на знаците в низа. В този случай лексикографският ред може да бъде нарушен и конвенцииприетите в определена културна среда се игнорират
OrdinalIgnoreCase Сравнението на низове се извършва с помощта на поредните стойности на знаците в низа, но без значение за малки и големи букви

И в двата случая методът Compare() връща отрицателна стойност, ако първият сравняван низ е по-малък от втория; положителна стойност, ако първият сравняван низ е по-голям от втория; и накрая нула, ако и двата сравнени низа са равни. Въпреки че методът Compare() връща нула, ако низовете, които се сравняват, са равни, обикновено е по-добре да използвате метода Equals() или оператора ==, за да определите дали символните низове са равни.

Факт е, че методът Compare() определя равенството на сравняваните низове въз основа на техния ред на сортиране. Например, ако низовете се сравняват културно, и двата низа може да са еднакви в техния ред на сортиране, но не по същество равни. По подразбиране равенството на низове се определя в метода Equals() въз основа на поредните стойности на знаците, а не културно. Следователно по подразбиране и двата низа се сравняват в този метод за абсолютно равенство знак по знак, подобно на начина, по който се прави в оператора ==.

Въпреки голямата гъвкавост на метода Compare(), за просто порядково сравнение на символни низове е по-лесно да използвате метода CompareOrdinal(). И накрая, имайте предвид, че методът CompareTo() сравнява само низове по чувствителен към културата начин.

Следващата програма демонстрира използването на методите Compare(), Equals(), CompareOrdinal() и операторите == и != за сравняване на символни низове. Имайте предвид, че първите два примера за сравнение ясно демонстрират разликите между културно чувствителните сравнения на низове и английските сравнения на редни числа:

Използване на системата; клас Пример ( static void Main() ( string str1 = "alpha"; string str2 = "Alpha"; string str3 = "Beta"; string str4 = "alpha"; string str5 = "alpha, beta"; int result; / / Първо, демонстрирайте разликите между чувствително към културата сравнение на низове и редов резултат за сравнение = String.Compare(str1, str2, StringComparison.CurrentCulture); Console.Write("Чувствително към култура сравнение на низове: "); if (резултат 0 ) Конзола .WriteLine(str1 + " е по-голямо от " + str2); else Console.WriteLine(str1 + "е " + str2); резултат = String.Compare(str1, str2, StringComparison.Ordinal); Console.Write("Поредно сравнение редове: "); if (резултат 0) Console.WriteLine(str1 + " е по-голямо от " + str2); else Console.WriteLine(str1 + "е равно на " + str4); // Използвайте резултата от метода CompareOrdinal() = String.CompareOrdinal( str1, str2); Console.Write("Сравнете низове с помощта на CompareOrdinal():\n"); if (резултат 0) Console.WriteLine(str1 + " по-голямо от " + str2); else Console.WriteLine (ул 1 + "е равно на " + str4); Console.WriteLine(); // Определяне на равенството на низовете с помощта на оператора == // Това е поредно сравнение на символни низове if (str1 == str4) Console.WriteLine(str1 + " == " + str4); // Откриване на неравенството на линията с помощта на оператора != if(str1 != str3) Console.WriteLine(str1 + " != " + str3); if(str1 != str2) Console.WriteLine(str1 + " != " + str2); Console.WriteLine(); // Извършване на сравняване на низове без значение за главни и малки букви с помощта на метода Equals() if(String.Equals(str1, str2, StringComparison.OrdinalIgnoreCase)) Console.WriteLine("Сравняване на низове с помощта на метода Equals() с параметър " + "OrdinalIgnoreCase : \n" + str1 + " е равно на " + str2); Console.WriteLine(); // Сравняване на части от низове if(String.Compare(str2, 0, str5, 0, 3, StringComparison.CurrentCulture) > 0) ( Console.WriteLine("Сравняване на низове въз основа на текущата култура:" + "\n3 първи знака на низа " + str2 + " е по-голям от първите 3 знака на низа " + str5); ) ) )

Изпълнението на тази програма води до следния резултат:

В езика C няма отделен тип данни "низ от знаци". Работата с низове се реализира чрез използване на едномерни масиви от типа char, т.е. символен низ е едномерен масив от символи, завършващ с нулев байт.

Нулев байт е байт, всеки бит от който е равен на нула, докато символната константа ´\0´ (терминатор на ред или нулев терминатор) е дефинирана за нулевия байт. Следователно, ако един низ трябва да съдържа k символа, тогава k+1 елемента трябва да бъдат посочени в описанието на масива.

Например char a; - означава, че низът може да съдържа шест символа, като последният байт е запазен за нула.

Константата на низ е набор от символи, затворени в двойни кавички. Например:

char S="Работа с низове";

Няма нужда изрично да се указва знакът ´\0´ в края на константата на низ.

Когато работите с низове, е удобно да използвате указатели, например:

x = "BSUIR";

x = (i>0)? "положително": (т<0)? "отрицательное":"нулевое";

Спомнете си, че две стандартни функции обикновено се използват за въвеждане на низове:

scanf()- въвежда стойности за низови променливи с входен спецификатор %спреди появата на първия знак „интервал“ (знакът „&“ не е необходимо да се посочва преди идентификатора на низовите данни);

получава ()- въвеждането на ред с интервали вътре в този ред завършва с натискане на клавиш ENTER.

И двете функции автоматично завършват низа с нулев байт.

Редовете се извеждат от функциите printf() или puts() до първия нулев байт ('\0'):

printf()не премества курсора след извеждане в началото на нов ред;

поставя ()автоматично премества курсора след изхода на информация за низ в началото на нов ред.

Например:

printf(" Въведете низ без интервали: \n");

scanf("%s",Str);

puts("Въведете низ");

Останалите операции върху низове се извършват с помощта на стандартни библиотечни функции, чиито прототипи са описани във файла низ.h. Нека да разгледаме най-често използваните функции.

int функция strlen(char *S) връща дължината на низа (броя знаци в низа), като игнорира крайния нулев байт.

char *S1=”Минск!\0”, S2=”BSUIR-Ура!”;

printf(“ %d, %d .”, strlen(S1), strlen(S2));

Резултатът от този раздел на програмата:

int функция strcpy(char *S1, char *S2) - копира съдържанието на низ S2 в низ S1.

функция strcat(char *S1, char *S2) - свързва низа S2 към низа S1 и го поставя в масива, където е бил низът S1, докато низът S2 не се променя. Нулевият байт, който завършва низ S1, се заменя с първия символ на низ S2.

int функция strcmp(char *S1, char *S2) сравнява низовете S1 и S2 и връща стойността<0, если S10 ако S1>S2; =0, ако низовете са равни, т.е. съдържат еднакъв брой еднакви знаци.

Функции за преобразуване на низ S в число:

Цяло число: int atoi(char*S);

Дълго цяло число: дълго атол(char*S);

Реално: двойно atof(char*S);

при грешка тези функции връщат 0.

Функции за преобразуване на число V в низ S.

»Надеждена SEO агенция Индия може да увеличи приходите на малкия бизнес

80% потребители търсят в Google и други търсачки, преди да направят покупка, а повече от 50% запитвания, генерирани чрез търсачките, се конвертират. Тези две статистики доказват важността на оптимизацията за търсачки. Има много подобни статистики и факти, които правят ясна точка: всеки малък, среден или голям бизнес се нуждае от професионални SEO услуги. Малките предприятия и стартиращите фирми често се сблъскват с бюджетни проблеми. Те могат да се възползват от помощта на всяка надеждна SEO агенция от Индия, за да получат най-добрата SEO услуга в своя бюджет, за да увеличат приходите си.
Търсенето оказва голямо влияние върху умовете на потребителите. Според различни статистики, споделени от големи експерти по оптимизация на търсачките на различни оторизирани уебсайтове като Search Engine Land, Moz, SEO Journal, Digital Marketers India, Hubspot и др. SEO улавя по-голямата част от потенциалните клиенти. Освен това потенциалните клиенти, идващи от органичните резултати от търсенето, имат по-висок процент на реализация. Тези статистики и поведението на потребителите показват по-ясно, че най-добрата SEO услуга не е лукс, а необходимост за всеки бизнес.
За да заобиколи конкуренцията и да увеличи растежа на бизнеса, всяка организация трябва да използва услугите за оптимизация за търсачки. Големите марки могат да инвестират достатъчно пари за експертна SEO услуга, предлагана от топ SEO компания или SEO специалист, но собствениците на малък бизнес често правят компромис с качеството на тази услуга поради по-малкия бюджет. Труден факт е, че малкият бизнес и стартиращите фирми в крайна сметка напускат възможностите, които могат да бъдат създадени с професионалната SEO услуга или използват евтина SEO услуга, която не води до положителни резултати.
Собствениците на малък бизнес и стартиращите компании могат да се възползват от професионалните SEO услуги дори и при ограничен бюджет. Най-доброто решение е намирането на надеждна SEO компания, базирана извън Индия. В Индия има много SEO експерти, които работят с агенцията за дигитален маркетинг и предлагат най-добрите услуги в бранша. Те могат да ви осигурят необходимите SEO услуги във вашия бюджет. Заплатите могат да бъдат договорени със SEO агенция в Индия, за да получите по-добри услуги на по-ниски цени. Въпреки това, не се поддавайте на евтина SEO услуга, която таксува по-малко и обещава да даде повече, тъй като експертизата идва на своя цена. Трябва да видите портфолиото или да зададете подходящи въпроси, преди да сключите договор с компания за вашия бизнес.
Експертите по SEO в Индия са квалифицирани с най-добрите практики за оптимизиране на търсачките. Освен това има някои специалисти по SEO в Индия, като Ash Vyas, които се специализират в създаването на най-добрата стратегия за оптимизация на търсачки за бизнес в посочения бюджет. SEO специалистите ще създадат ясен план и ще споделят какви могат да бъдат очакваните резултати. По този начин можете да сте добре запознати с вашата инвестиция и възвръщаемост. Това помага при вземането на по-добро бизнес решение.
Добра идея е възможно най-скоро да намерите и сключите договор с надеждна SEO компания от Индия, която предлага най-добрите SEO услуги. Можете също така да започнете с малък бюджет и ограничени дейности, за да започнете да индексирате уеб страниците си и да увеличите ключовите си думи в търсачките. Не чакайте идеалното време или ден, когато ще имате хиляди долари, които да инвестирате в най-добрите SEO услуги. Ранното започване ще ви помогне да постигнете по-бързи резултати, когато можете да станете агресивни с маркетинговия си подход. Надеждна SEO компания, базирана в Индия, ще ви помогне да определите вашите настоящи и бъдещи планове за постигане на добри резултати. Повече индексирани страници, повишени класации и надеждна марка на вашия бизнес, създадени с непрекъснати професионални SEO практики, ще удвоят запитванията, бизнеса и приходите. Всеки малък бизнес може да започне с двуцифрена инвестиция в професионални SEO услуги. Има много SEO агенции в Индия, които предлагат нисък бюджет, но са резултат от ориентирани услуги за оптимизация на търсачки.

анкети от изгнание

  • CraigWew

    12.04.2018

    »Значението на установяването на връзка с клиента в областта на недвижимите имоти и общите продажби

    Важността на установяването на връзка с клиента.
    Установяването на връзка с клиента трябва да се спечели и към него трябва да се подходи като към неразделна част от процеса на продажба.
    За да накарате клиента и себе си да се свържете на реална база едно към едно, включва две неща!
    Първо, ще трябва да сте наясно и да сте там! Второ, трябва да разберете, че има два различни етапа, които ще настъпят по време на този процес.
    А-Бъдете там-какво означава това?
    o Повечето хора наистина не слушат друг човек, докато говорят. Обикновено те са толкова заети да формулират следващия си отговор или твърдение, че не могат да слушат наистина.
    o Ако това звучи като вас, да сте там означава да млъкнете и да слушате!
    B-Какъв е първият или начален етап?
    o Обикновено имате само няколко минути, за да се утвърдите в съзнанието на клиентите като човек, с когото те искат да работят.
    o Когато се съмнявате, най-добре е първо да задавате въпроси, които ще ги привлекат и ще говорят за себе си.
    o Също така винаги е безопасно да изглеждате като професионалист - нямам предвид стоик или сух, а някой, който знае какво прави, говори и изглежда като част.
    C-Други етапи
    o С течение на времето чрез разговор и въпроси, които ще имат, вие или ще установите способността си, или не.
    o Имайте предвид, че вероятно ще ви мерят известно време. Добрата новина е, че в един момент, ако сте успели да установите връзка, те ще се отпуснат и двамата ще можете да се концентрирате върху намирането или продажбата на дома.
    Какво друго може да ми помогне да развия разбирателство?
    o Като се опитвате да разберете различните типове личности и след това като казвате и задавате правилните въпроси.
    o Ако имате добри отношения (попаднете на същата дължина на вълната като клиента), тогава продажбата е приключила, сега е само въпрос на намиране на подходящия дом или попълване на документите за обява.
    Ами различните личности
    o Тъй като това не е книга за психиатрия, засега разберете само два основни типа.
    o Има интровертни и екстровертни хора.
    o Знаете вида. Помислете за трима души, които познавате и отговарят на всяка класификация.
    Какво ще кажете за езика на тялото и говорните модели?
    o Ако говорят бързо или бавно, опитайте се да имитирате техните говорни модели.
    o Ако говорят високо или тихо, направете същото. Наклонени ли са напред или назад?
    o Излишно е да казвам, че има много книги, написани по този въпрос. Просто имайте предвид, че това е важен фактор – особено когато седите в конферентна зала или в нечий дом и обсъждате сделка за $400 000.
    Развиването на разбирателство е умение, което може да се научи и подобри.
    o Всички сме се сблъсквали с продавач, който ни е продал нещо, но въпреки това не сме се чувствали сякаш ни продават. Причината е, че той или тя ви е накарал да се чувствате комфортно там, където сте им имали доверие.
    Как да развием разбирателство?
    o Използвайте очите и ушите си и задавайте въпроси. да обясни
    o Използвайте очите:
    o Погледнете роклята им - колата им - личните им вещи и наистина искам да кажа, погледнете ги и дешифрирайте какво ви казва това за тях.
    o Използвайте ушите:
    o Слушайте какво казват и задавайте въпроси, за да стигнете до дъното на истинската им МОТИВАЦИЯ!
    Сега, по време на целия този разговор, вероятно ще има едно или две неща, които ще откриете, че имате общо с тях. (Семейство, географски райони, риболов и т.н.) Когато срещнете общ език, уведомете ги, че сте запознати и след това отделете минута, за да го обсъдите с тях.
    Каква е целта?
    o След като ви приемат като един от тях, вие сте в състояние наистина да имате страхотен опит в продажбата, тъй като вече работите заедно, а след това като екип—вече не сте продавачът, сега сте на позиция на съветник .
    o Запомнете, клиентът ще ви позволи или няма да ви позволи да влезете в неговия свят. Ако разбирате това и наистина работите усилено, за да станете съпричастни с него/нея, можете да спечелите позиция на доверие. В повечето случаи всъщност ще ги видите да се отпускат (език на тялото), когато това се случи, вие сте на път.
    o За да илюстрирате това някога изнасяли ли сте реч и сте забелязали, че когато най-накрая се свържете с член на публиката, той ще кима одобрително. Всички тези неща може да изглеждат банални, но не са.
    В заключение, ако можете да спечелите доверието на клиентите, продажбата на продукт или услуга е много по-лесна и изживяването може да бъде приятно за всички участници.
    Винаги помнете, че победа/победа е най-добрата ситуация.

Съвременният стандарт C++ дефинира клас с функции и свойства (променливи) за организиране на работа с низове (в класическия език C няма низове като такива, има само масиви от знаци):

#включи

#включи

#включи

За да работите с низове, трябва също да включите стандартно пространство от имена:

Използване на пространство от имена std;

В противен случай ще трябва да посочите дескриптора на класа std::string вместо string навсякъде.

Следното е пример за програма, която работи с низ (не работи в стари C-съвместими компилатори!):

#включи #включи #включи използване на пространство от имена std; int main() (низ s = "Тест"; s.insert(1,"!"); cout<< s.c_str() << endl; string *s2 = new string("Hello"); s2->изтриване (s2->край ()); cout<< s2->c_str(); cin.get(); връщане 0; )

Основните характеристики, които класът низ има:

  • инициализация с масив от знаци (вграден низ) или друг обект от тип string. Вграденият тип няма втората възможност;
  • копиране на един ред в друг. За вграден тип трябва да използвате функцията strcpy();
  • достъп до отделни символи на низ за четене и запис. Във вградения масив това става с помощта на операцията индекс или индиректно адресиране с помощта на указател;
  • сравняване на два низа за равенство. За вграден тип се използват функциите на семейството strcmp();
  • конкатенация (конкатенация) на два низа, даваща резултата или като трети низ, или вместо един от оригиналните. За вграден тип се използва функцията strcat(), но за да получите резултата в нов ред, трябва да използвате последователно функциите strcpy() и strcat() и също така да се погрижите за разпределението на паметта;
  • вградени средства за определяне на дължината на низ (функции-членове на класа size() и l ength()). Единственият начин да разберете дължината на низ от вграден тип е като го изчислите с функцията strlen();
  • способността да разберете дали даден низ е празен.

Нека разгледаме по-отблизо тези основни функции.

Инициализация на низпри описване и дължина на низа(без да включва завършващия нулев терминатор):

String st("Моят низ\n"); cout<< "Длина " << st << ": " << st.size() << " символов, включая символ новой строки\n";

Низът може да бъде и празен:

Низ st2;

За да проверите дали е низът празен, можете да сравните дължината му с 0:

if (!st.size()) // празно

или използвайте метода empty(), който връща true за празен низ и false за непразен:

if (st.empty()) // празно

Третата форма на създаване на низ инициализира обект от тип string с друг обект от същия тип:

Низ st3(st);

Низът st3 се инициализира с низа st. Как можем да се уверим, че тези низовете съвпадат? Нека използваме оператора за сравнение (==):

Ако (st == st3) // инициализацията е успешна

как копирайте един ред в друг? С обичайния оператор за присвояване:

st2 = st3; // копиране на st3 в st2

За конкатенация на низовеизползва се операторът за добавяне (+) или операторът за добавяне-присвояване (+=). Нека са дадени два реда:

Низ s1("здравей, "); низ s2("свят\n");

Можем да получим трети низ, състоящ се от конкатенацията на първите два, по този начин:

Низ s3 = s1 + s2;

Ако искаме да добавим s2 към края на s1, трябва да напишем:

S1 += s2;

Операцията за добавяне може да свързва обекти на клас низне само помежду си, но и със струни от вграден тип. Можете да пренапишете примера по-горе, така че специалните символи и препинателните знаци да бъдат представени от вградения тип char *, а значимите думи да бъдат представени от обекти от клас низ:

Const char *pc = ", "; низ s1("здравей"); низ s2("свят"); низ s3 = s1 + pc + s2 + "\n"; cout<< endl << s3;

Такива изрази работят, защото компилаторът "знае" как автоматично да конвертира обекти от вграден тип в обекти от клас string. Възможно е също така просто да присвоите вграден низ към низов обект:

Низ s1; const char *pc = "масив от знаци"; s1=pc; // правилно

Обратната трансформация е не работи. Опитът да се извърши следната инициализация на вграден тип низ ще доведе до грешка при компилиране:

Char*str = s1; // грешка при компилиране

За да направите това преобразуване, трябва изрично да извикате членската функция, наречена c_str() ("C низ"):

Const char *str = s1.c_str();

Функцията c_str() връща указател към масив от символи, съдържащ низа на низовия обект, както би било във вградения тип низ. Ключовата дума const тук предотвратява "опасната" възможност в съвременните визуални среди за директно модифициране на съдържанието на обект чрез указател.

Да се отделни героиобект от тип string, подобно на вграден тип, може да бъде достъпен с помощта на операцията индекс. Например, ето кодов фрагмент, който замества всички точки с долна черта:

String str("www.disney.com"); int size = str.size(); за (int i = 0; i< size; i++) if (str[i] == ".") str[ i ] = "_"; cout << str;

Замяна (str.begin(), str.end(), ".", "_");

Вярно е, че тук не се използва методът за замяна на класа низ, а алгоритъмът със същото име:

#включи

Тъй като низовият обект се държи като контейнер, към него могат да се прилагат други алгоритми. Това ви позволява да решавате проблеми, които не се решават директно от функциите на класа string.

По-долу е дадено кратко описание на основните оператори и функции на класа низ, връзките в таблицата водят до описания на руски език в Интернет. За по-пълен списък на възможностите на класа string вижте например Wikipedia или cplusplus.com.

Задаване на знаци в низ

оператор=

присвоява стойности на низ

възлагам

присвоява знаци на низ

Достъп до отделни знаци

при

получаване на посочения знак с проверка за индекс извън границите

оператор

получаване на посочения знак

отпред

получаване на първия знак

обратно

получаване на последния знак

данни

връща указател към първия символ на низ

c_str

се завръща непроменяем C масив от символи, съдържащ символите на низа

Проверка за капацитет на низа

празен

проверява дали даден низ е празен

размер
дължина

връща броя знаци в низ

максимален_размер

връща максималния брой знаци

резерв

запазва място за съхранение

Операции върху низ

ясно

изчиства съдържанието на низа

вмъкнете

вмъкване на знаци

изтрива

премахване на символи

избутвам

добавяне на символ в края на низ

pop_back

премахва последния знак

добавям

оператор+=

добавя знаци в края на низ

сравнявам

сравнява два низа

замени

замества всяко появяване на посочения знак

подстр

връща подниз

копие

копира символи

преоразмеряване

променя броя на съхранените знаци

струни. Линеен вход/изход. Форматиран I/O. Обработка на низове чрез стандартни функции на езика C. Работа с памет.

1.1. Деклариране и инициализиране на низове.

Низът е масив от знаци, който завършва с празния знак '\0'. Низът се декларира като нормален масив от знаци, например,

char s1; // низ с дължина девет знака

char*s2; // указател към низ

Разликата между указателите s1 и s2 е, че указателят s1 е именувана константа, докато указателят s2 е променлива.

Константите на низовете са затворени в двойни кавички, за разлика от символите, които са затворени в единични кавички. Например,

„Това е низ.“

Дължината на низовата константа не може да надвишава 509 символа според стандарта. Много реализации обаче позволяват по-дълги низове.

Когато инициализирате низове, по-добре е да не указвате размерността на масива; компилаторът ще направи това, като преброи дължината на низа и добави единица към него. Например,

char s1 = „Това е низ.“;

В езика за програмиране C има голям брой функции за работа с низове, прототипите на които са описани в заглавните файлове stdlib.h и string.h. Работата с тези функции ще бъде обсъдена в следващите параграфи.

1.2. Линеен вход/изход.

За да въведете низ от конзолата, използвайте функцията

char* получава (char*str);

който записва низ на адрес str и връща адреса на входния низ. Функцията спира въвеждането, ако срещне символа '\n' или EOF (край на файла). Знакът за нов ред не се копира. Нулев байт се поставя в края на прочетения ред. При успех функцията връща указател към прочетения ред, а при неуспех NULL.

За да изведете низ към конзолата, използвайте стандартната функция

int поставя (const char *s);

което връща неотрицателно число при успех и EOF при неуспех.

Прототипите на функцията gets и puts са описани в заглавния файл stdio.h.

#включи

printf("Въведен низ: ");

1.3. Форматиран I/O.

За форматиран вход от конзолата използвайте функцията

int scanf (const char *format, ...);

който връща броя на прочетените единици данни при успех и EOF при неуспех. Параметърът за формат трябва да сочи към форматен низ, който съдържа спецификации на входния формат. Броят и типовете аргументи, които следват след форматиращия низ, трябва да съвпадат с броя и типовете входни формати, посочени във форматиращия низ. Ако това условие не е изпълнено, тогава резултатът от функцията е непредвидим.

Знаците за интервал, "\t" или "\n" във форматиращия низ описват един или повече празни символа във входния поток, които включват следните знаци: интервал, '\t', '\n', '\v', '\f'. Функцията scanf пропуска нулеви знаци във входния поток.

Буквалните знаци във форматиращ низ, с изключение на знака %, изискват точно същите знаци да се появят във входния поток. Ако няма такъв символ, scanf спира въвеждането. Функцията scanf пропуска буквални знаци.

Като цяло спецификацията на входния формат е:

Тип %[*] [ширина] [модификатори].

Знакът '*' означава пропуск при въвеждане на поле, дефинирано от тази спецификация;

- 'width' определя максималния брой знаци, въведени от тази спецификация;

Типът може да приема следните стойности:

c е масив от знаци,

s – символен низ, низовете са разделени с празни знаци,

d е цяло число със знак при 10 s/s,

i е цяло число със знак, числовата система се основава на първите две цифри,

u е цяло число без знак в 10 s/s,

o е цяло число без знак в 8 s/s,

x, X е цяло число без знак в 16 s/s,

e, E, f, g, G - плаващо число,

p е указател към указател,

n е указател към цяло число,

[…] е масив от сканирани знаци, например .

В последния случай от входния поток ще бъдат въведени само символите, затворени в квадратни скоби. Ако първият знак в квадратните скоби е '^', тогава се въвеждат само онези знаци, които не са включени в масива. Диапазонът от знаци в масива се определя чрез знака '-'. Когато се въвеждат знаци, се въвеждат и началните празни знаци и крайният нулев байт на низа.

Модификаторите могат да приемат следните стойности:

h е кратко цяло число,

l, L - дълго цяло число или плаващо число,

и се използват само за цели числа или плаващи числа.

Следващият пример показва случаи на използване на функцията scanf. Обърнете внимание, че спецификаторът на формата се предшества от интервал преди въвеждането на плаващо число.

#включи

printf("Въведете цяло число: ");

scanf("%d", &n);

printf("Въведете двойно: ");

scanf(" %lf", &d);

printf("Въведете знак: ");

scanf(" %c", &c);

printf("Въведете низ: ");

scanf("%s", &s);

Имайте предвид, че в тази програма числото с плаваща запетая се инициализира. Това се прави, за да може компилаторът да включва библиотека за поддръжка на работа с плаващи числа. Ако това не бъде направено, ще възникне грешка по време на изпълнение при въвеждане на плаващо число.

За форматиран изход към конзолата използвайте функцията

int printf (const char *format, ...);

който връща броя на изходните единици при успех и EOF при неуспех. Параметърът format е форматиращ низ, който съдържа спецификации на изходния формат. Броят и типовете аргументи, които следват форматиращия низ, трябва да съответстват на броя и типовете на спецификациите на изходния формат, дадени във форматиращия низ. Като цяло спецификацията на изходния формат е:

%[флагове] [ширина] [.прецизност] [модификатори] тип

- ‘флагове’ са различни символи, които указват изходния формат;

- 'width' определя минималния брой знаци, извеждани от тази спецификация;

- ‘.precision’ определя максималния брой знаци, които трябва да бъдат изведени;

- ‘модификаторите’ определят вида на аргументите;

- 'type' указва типа на аргумента.

Следният изходен формат се използва за отпечатване на цели числа със знак:

%[-] [+ | пространство] [ширина] [l] d

- – подравняване вляво, по подразбиране – вдясно;

+ - показва се знакът '+', имайте предвид, че за отрицателни числа винаги се показва знакът '-';

‘интервал’ – на мястото на символа се показва интервал;

d е типът данни int.

За извеждане на цели числа без знак се използва следният изходен формат:

%[-] [#] [ширина] [l]

# - показва начална 0 за числа в 8 c/c или начална 0x или 0X за числа в 16 c/c,

l – модификатор на тип дълги данни;

u е цяло число в 10c/c,

o е цяло число в 8 c/c,

x, X е цяло число в 16 c/c.

За показване на числа с плаваща запетая се използва следният изходен формат:

%[-] [+ | интервал] [ширина] [.прецизност]

„прецизност“ се отнася до броя на цифрите след десетичната запетая за форматите f, e и E или броя на значещите цифри за форматите g и G. Числата се закръглят. По подразбиране е шест десетични цифри с точност;

f е число с фиксирана точка,

e е число в експоненциална форма, експонентата се обозначава с буквата "e",

E е число в експоненциална форма, експонентата се обозначава с буквата "E",

g е най-краткият от форматите f или g,

G е най-краткият от форматите f или G.

printf ("n = %d\n f = %f\n e = %e\n E = %E\n f = %.2f", -123, 12.34, 12.34, 12.34, 12.34);

// отпечатва: n = 123 f = 12.340000 e = 1.234000e+001 E = 1.234000E+001 f = 12.34

1.4. Форматиране на низове.

Има варианти на функциите scanf и printf, които са предназначени за форматиране на низове и се наричат ​​съответно sscanf и sprintf.

int sscanf (const char *str, const char *format, ...);

чете данни от низа, посочен от параметъра str, според низа за формат, посочен от параметъра за формат. Връща количеството прочетени данни при успех, EOF при неуспех. Например,

#включи

char str = "a 10 1.2 Низ без въвеждане";

sscanf(str, "%c %d %lf %s", &c, &n, &d, s);

printf("%c\n", c); // отпечатва: a

printf("%d\n", n); // отпечатва: 10

printf("%f\n", d); // разпечатва: 1.200000

printf("%s\n", s); // отпечатва: низ

int sprintf (char *buffer, const char *format, ...);

форматира низа според формата, зададен от параметъра format, и записва резултата в буферния символен масив. Функцията връща броя знаци, записани в масива от символи на буфера, с изключение на крайния нулев байт. Например,

#включи

char str = "c = %c, n = %d, d = %f, s = %s";

char s = "Това е низ.";

sprintf(буфер, str, c, n, d, s);

printf("%s\n", буфер); // отпечатва: c = c, n = 10, d = 1.200000, s = Това е низ

1.5. Преобразувайте низове в числови данни.

Прототипите на функциите за конвертиране на низове в числови данни са дадени в заглавния файл stdlib.h, който трябва да бъде включен в програмата.

За да преобразувате низ в цяло число, използвайте функцията

int atoi (const char *str);

char *str = "-123";

n = atoi(str); // n = -123

За да конвертирате низ в дълго цяло число, използвайте функцията

long int atol (const char *str);

което, ако е успешно, връща цялото число, в което низът str е бил преобразуван, и 0, ако е неуспешно.Например,

char *str = "-123";

n = atol(str); // n = -123

За да преобразувате низ в двоен, използвайте функцията

двойно atof (const char *str);

който, ако е успешен, връща плаващо число от тип double, в което се преобразува низът str, а в случай на неуспех, 0. Например,

char *str = "-123.321";

n = atof(str); // n = -123.321

Следните функции изпълняват подобни действия на atoi, atol, atof, но предоставят повече функционалност.

long int strtol (const char *str, char **endptr, int base);

преобразува низа str в long int, който връща. Параметрите на тази функция имат следната цел.

Ако основният аргумент е 0, тогава преобразуването зависи от първите два знака на str:

Ако първият знак е цифра от 1 до 9, тогава се приема, че числото е представено в 10 c/c;

Ако първият знак е числото 0, а вторият знак е число от 1 до 7, тогава се приема, че числото е представено в 8 c/c;

Ако първият знак е 0, а вторият знак е „X“ или „x“, тогава се приема, че числото е представено в 16 c/c.

Ако основният аргумент е число от 2 до 36, тогава тази стойност се приема като основа на числовата система и всеки знак, който излиза извън тази система, спира преобразуването. Числените системи с основа от 11 до 36 използват символите „A“ до „Z“ или „a“ до „z“ за представяне на цифри.

Стойността на аргумента endptr се задава от функцията strtol. Тази стойност съдържа указател към знака, който е спрял преобразуването на str. Функцията strtol връща преобразуваното число при успех и 0 при неуспех.Например,

n = strtol("12a", &p, 0);

printf(" n = %ld, %stop = %c, n, *p); // n = 12, стоп = a

n = strtol("012b", &p, 0);

printf(" n = %ld, %stop = %c, n, *p); // n = 10, стоп = b

n = strtol("0x12z", &p, 0);

printf(" n = %ld, %stop = %c, n, *p); // n = 18, стоп = z

n = strtol("01117", &p, 0);

printf(" n = %ld, %stop = %c, n, *p); // n = 7, стоп = 7

unsigned long int strtol (const char *str, char **endptr, int base);

работи подобно на функцията strtol, но преобразува символното представяне на число в unsigned long int.

двоен strtod (const char *str, char **endptr);

преобразува символното представяне на число в двойно.

Всички функции, изброени в този параграф, спират работата си, когато срещнат първия знак, който не отговаря на формата на въпросното число.

Освен това, ако стойността на символа на число надвишава диапазона от допустими стойности за съответния тип данни, тогава функциите atof, strtol, strtoul, strtod задават стойността на променливата errno на ERANGE. Променливата errno и константата ERANGE са дефинирани в заглавния файл math.h. Функциите atof и strtod връщат HUGE_VAL, функцията strtol връща LONG_MAX или LONG_MIN, а функцията strtoul връща ULONG_MAX.

Нестандартните функции itoa, ltoa, utoa, ecvt, fcvt и gcvt могат да се използват за преобразуване на числови данни в символни низове. Но е по-добре да използвате стандартната функция sprintf за тези цели.

1.6. Стандартни функции за работа с низове.

В този раздел се разглеждат функции за работа с низове, прототипите на които са описани в заглавния файл string.h.

1. Сравнение на низове.Функциите strcmp и strncmp се използват за сравняване на низове.

int strcmp (const char *str1, const char *str2);

сравнява низовете str1, str2 лексикографски и връща -1, 0 или 1, ако str1 е съответно по-малък, равен или по-голям от str2.

int strncmp (const char *str1, const char *str2, size_t n);

лексикографски сравнява най-много първите n знака от низовете str1 и str2. Функцията връща -1, 0 или 1, ако първите n знака от str1 са съответно по-малки, равни или по-големи от първите n знака от str2.

// пример за сравнение на низове

#включи

#включи

char str1 = "aa bb";

char str2 = "aa aa";

char str3 = "aa bb cc";

printf("%d\n", strcmp(str1, str3)); // отпечатва: -1

printf("%d\n", strcmp(str1, str1)); // отпечатва: -0

printf("%d\n", strcmp(str1, str2)); // отпечатва: 1

printf("%d\n", strncmp(str1, str3, 5)); // отпечатва: 0

2. Копиране на линии.Функциите strcpy и strncpy се използват за копиране на низове.

char *strcpy (char *str1, const char *str2);

копира низа str2 в низа str1. Низът str2 се копира изцяло, включително крайния нулев байт. Функцията връща указател към str1. Ако линиите се припокриват, тогава резултатът е непредвидим.

char *strncpy (char *str1, const char *str2, size_t n);

копира n знака от низ str2 в низ str1. Ако низът str2 съдържа по-малко от n символа, тогава последният нулев байт се копира толкова пъти, колкото е необходимо, за да се разшири низът str2 до n знака. Функцията връща указател към низа str1.

char str2 = "Копирай низ.";

strcpy(str1, str2);

printf(str1); // отпечатва: Копиране на низ.

4. Свързващи струни.Функциите strcat и strncat се използват за свързване на низове в един низ.

char* strcat (char *str1, const char *str2);

добавя низа str2 към низа str1, като крайният нулев байт на низа str1 е изтрит. Функцията връща указател към низа str1.

char* strncat (char *str1, const char *str2, size_t n);

свързва n знака от низ str2 към низ str1, изтривайки крайния нулев байт на str1. Функцията връща указател към низа str1. ако дължината на низа str2 е по-малка от n, тогава се добавят само символите, включени в низа str2. След конкатенация на низ, към str1 винаги се добавя нулев байт. Функцията връща указател към низа str1.

#включи

#включи

char str1 = "низ";

char str2 = "катенация";

char str3 = "Да Не";

strcat(str1, str2);

printf("%s\n", str1); // отпечатва: Катениране на низове

strncat(str1, str3, 3);

printf("%s\n", str1); // отпечатва: Катениране на низ Да

5. Търсене на знак в низ.Функциите strchr, strrchr, strspn, strcspn и strpbrk се използват за търсене на знак в низ.

char* strchr (const char *str, int c);

търси първото срещане на знака, определен от параметър c в низа str. При успех функцията връща указател към първия намерен символ, а при неуспех NULL.

char* strrchr (const char *str, int c);

търси последното срещане на знака, определен от параметър c в низа str. При успех функцията връща указател към последния намерен знак, а при неуспех NULL.

#включи

#включи

char str = "търсене на char";

printf("%s\n", strchr(str, "r")); // отпечатва: r търсене

printf("%s\n", strrchr(str, "r")); // отпечатва: rch

size_t strspn (const char *str1, const char *str2);

връща индекса на първия знак в str1, който не е в str2.

size_t strcspn (const char *str1, const char *str2);

връща индекса на първия знак в str1, който е в str2.

char str = "123 abc";

printf("n = %d\n", strspn(str, "321"); // отпечатва: n = 3

printf ("n = %d\n", strcspn (str, "cba"); // отпечатва: n = 4

char* strpbrk (const char *str1, const char *str2);

намира първия знак в str1, който е равен на един от знаците в str2. При успех функцията връща указател към този знак, а при неуспех NULL.

char str = "123 abc";

printf("%s\n", strpbrk(str, "bca")); // отпечатва: abc

6. Сравнение на низове.Функцията strstr се използва за сравняване на низове.

char* strstr (const char *str1, const char *str2);

намира първото срещане на низа str2 (без нулевия байт в края) в низа str1. При успех функцията връща указател към намерения подниз, а при неуспех NULL. Ако указателят str1 сочи към низ с нулева дължина, тогава функцията връща указателя str1.

char str = "123 abc 456;

printf("%s\n", strstr(str, "abc"); // печат: abc 456

7. Анализиране на низ в токени.Функцията strtok се използва за анализиране на низ в токени.

char* strtok (char *str1, const char *str2);

връща указател към следващия токен (дума) в низ str1, където разделителите на токени са знаци от низ str2. Ако токените са свършили, тогава функцията връща NULL. При първото извикване на функцията strtok параметърът str1 трябва да сочи към низ, който се анализира на токени, а при следващи извиквания този параметър трябва да бъде зададен на NULL. След като намери токена, функцията strtok записва нулев байт след този токен на мястото на разделителя.

#включи

#включи

char str = "12 34 ab cd";

p = strtok(str, " ");

printf("%s\n",p); // отпечатва стойности в колона: 12 34 ab cd

p = strtok(NULL, " ");

8. Определяне на дължината на низа.Функцията strlen се използва за определяне на дължината на низ.

size_t strlen(const char *str);

връща дължината на низа, като игнорира последния нулев байт. Например,

char str = "123";

printf("len = %d\n",strlen(str)); // отпечатва: len = 3

1.7. Функции за работа с памет.

Заглавният файл string.h също описва функции за работа с блокове памет, които са подобни на съответните функции за работа с низове.

void* memchr(const void *str, int c, size_t n);

търси първото срещане на знака, определен от c в n байта на str.

int memcmp(const void *str1, const void *str2, size_t n);

сравнява първите n байта на str1 и str2.

void* memcpy(const void *str1, const void *str2, size_t n);

копира първите n байта от низ str1 в низ str2.

void* memmove(const void *str1, const void *str2, size_t n);

копира първите n байта от str1 в str2, като гарантира, че припокриващите се низове се обработват правилно.

void* memset(const void *str, int c, size_t n);

копира символа, зададен от c, в първите n байта на str.

2022 bar812.ru. Само за комплекса. Програми. Желязо. Интернет. Windows