Строка (C++/CLI и C++/CX) String (C++/CLI and C++/CX)

Среда выполнения Windows и среда CLR представляют строки в виде объектов, управление выделяемой памятью которых осуществляется автоматически. The Windows Runtime and common language runtime represent strings as objects whose allocated memory is managed automatically. Это значит, что в случае выхода строковой переменной за пределы области видимости или завершении работы приложения явно отменять память для строки не требуется. That is, you are not required to explicitly discard the memory for a string when the string variable goes out of scope or your application ends. Чтобы указать, что управление временем существования строкового объекта должно осуществляться автоматически, следует объявить тип string с помощью модификатора дескриптор объекта (^). To indicate that the lifetime of a string object is to be managed automatically, declare the string type with the handle-to-object (^) modifier.

Среда выполнения Windows Windows Runtime

Архитектура среды выполнения Windows требует реализации типа данных String в пространстве имен Platform . The Windows Runtime architecture requires that the String data type be located in the Platform namespace. Для удобства в Visual C++ также предусмотрен тип данных string , являющийся синонимом для Platform::String в пространстве имен default . For your convenience, Visual C++ also provides the string data type, which is a synonym for Platform::String , in the default namespace.

Синтаксис Syntax

Требования Requirements

Параметр компилятора: /ZW Compiler option: /ZW

Среда CLR Common Language Runtime

При компиляции с параметром /clr компилятор преобразует строковые литералы в строки типа String. When compiling with /clr , the compiler will convert string literals to strings of type String. Для сохранения обратной совместимости с существующим кодом у этого правила есть два исключения: To preserve backward compatibility with existing code there are two exceptions to this:

Обработка исключений. Exception handling. Если появляется строковый литерал, компилятор перехватывает его как строковый литерал. When a string literal is thrown, the compiler will catch it as a string literal.

Определение шаблона. Template deduction. Если строковый литерал передается в качестве аргумента шаблона, компилятор не преобразует его в String. When a string literal is passed as a template argument, the compiler will not convert it to a String. Обратите внимание, что строковые литералы, переданные в качестве универсального аргумента, повышаются до String. Note, string literals passed as a generic argument will be promoted to String.

В компиляторе также есть встроенная поддержка трех операторов, которые можно переопределять для настройки их поведения: The compiler also has built-in support for three operators, which you can override to customize their behavior:

System::String^ operator +( System::String, System::String); System::String^ operator +( System::String, System::String);

System::String^ operator +( System::Object, System::String); System::String^ operator +( System::Object, System::String);

System::String^ operator +( System::String, System::Object); System::String^ operator +( System::String, System::Object);

После передачи String компилятор при необходимости упаковывает, а затем объединяет объект (с помощью ToString) со строкой. When passed a String, the compiler will box, if necessary, and then concatenate the object (with ToString) with the string.

Курсор («^») означает, что объявленная переменная является дескриптором управляемого объекта C++/CLI. The caret («^») indicates that the declared variable is a handle to a C++/CLI managed object.

Дополнительные сведения см. в статье Строковые и символьные литералы (C++). For more information see String and Character Literals.

Требования Requirements

Параметр компилятора: /clr Compiler option: /clr

Примеры Examples

В следующем примере кода демонстрируется объединение и сравнение строк. The following code example demonstrates concatenating and comparing strings.

В следующем примере показано, что предоставляемые компилятором операторы можно перегружать, и что компилятор будет искать перегрузку функции на основе типа String. The following sample shows that you can overload the compiler-provided operators, and that the compiler will find a function overload based on the String type.

В следующем примере показано, что компилятор различает собственные строки и строки String. The following sample shows that the compiler distinguishes between native strings and String strings.

String handling in C++/WinRT

With C++/WinRT, you can call Windows Runtime APIs using C++ Standard Library wide string types such as std::wstring (note: not with narrow string types such as std::string). C++/WinRT does have a custom string type called winrt::hstring (defined in the C++/WinRT base library, which is %WindowsSdkDir%Include\ \cppwinrt\winrt\base.h ). And that’s the string type that Windows Runtime constructors, functions, and properties actually take and return. But in many cases—thanks to hstring‘s conversion constructors and conversion operators—you can choose whether or not to be aware of hstring in your client code. If you’re authoring APIs, then you’re more likely to need to know about hstring.

There are many string types in C++. Variants exist in many libraries in addition to std::basic_string from the C++ Standard Library. C++17 has string conversion utilities, and std::basic_string_view, to bridge the gaps between all of the string types. winrt::hstring provides convertibility with std::wstring_view to provide the interoperability that std::basic_string_view was designed for.

Using std::wstring (and optionally winrt::hstring) with Uri

But hstring has conversion constructors that let you work with it without needing to be aware of it. Here’s a code example showing how to make a Uri from a wide string literal, from a wide string view, and from a std::wstring.

The property accessor Uri::Domain is of type hstring.

But, again, being aware of that detail is optional thanks to hstring‘s conversion operator to std::wstring_view.

Uri implements the IStringable interface.

You can use the hstring::c_str function to get a standard wide string from an hstring (just as you can from a std::wstring).

If you have an hstring then you can make a Uri from it.

Consider a method that takes an hstring.

All of the options you’ve just seen also apply in such cases.

hstring has a member std::wstring_view conversion operator, and the conversion is achieved at no cost.

winrt::hstring functions and operators

A host of constructors, operators, functions, and iterators are implemented for winrt::hstring.

An hstring is a range, so you can use it with range-based for , or with std::for_each . It also provides comparison operators for naturally and efficiently comparing against its counterparts in the C++ Standard Library. And it includes everything you need to use hstring as a key for associative containers.

We recognize that many C++ libraries use std::string, and work exclusively with UTF-8 text. As a convenience, we provide helpers, such as winrt::to_string and winrt::to_hstring, for converting back and forth.

WINRT_ASSERT is a macro definition, and it expands to _ASSERTE.

For more examples and info about hstring functions and operators, see the winrt::hstring API reference topic.

The rationale for winrt::hstring and winrt::param::hstring

The Windows Runtime is implemented in terms of wchar_t characters, but the Windows Runtime’s Application Binary Interface (ABI) is not a subset of what either std::wstring or std::wstring_view provide. Using those would lead to significant inefficiency. Instead, C++/WinRT provides winrt::hstring, which represents an immutable string consistent with the underlying HSTRING, and implemented behind an interface similar to that of std::wstring.

You may notice that C++/WinRT input parameters that should logically accept winrt::hstring actually expect winrt::param::hstring. The param namespace contains a set of types used exclusively to optimize input parameters to naturally bind to C++ Standard Library types and avoid copies and other inefficiencies. You shouldn’t use these types directly. If you want to use an optimization for your own functions then use std::wstring_view. Also see Passing parameters into the ABI boundary.

The upshot is that you can largely ignore the specifics of Windows Runtime string management, and just work with efficiency with what you know. And that’s important, given how heavily strings are used in the Windows Runtime.

Formatting strings

One option for string-formatting is std::wostringstream. Here’s an example that formats and displays a simple debug trace message.

The correct way to set a property

You set a property by passing a value to a setter function. Here’s an example.

The code below is incorrect. It compiles, but all it does is to modify the temporary winrt::hstring returned by the Text() accessor function, and then to throw the result away.

C – Strings and String functions with examples

By Chaitanya Singh | Filed Under: c-programming

String is an array of characters. In this guide, we learn how to declare strings, how to work with strings in C programming and how to use the pre-defined string handling functions.

We will see how to compare two strings, concatenate strings, copy one string to another & perform various string manipulation operations. We can perform such operations using the pre-defined functions of “string.h” header file. In order to use these string functions you must include string.h file in your C program.

String Declaration

Method 1:

Method 2: The above string can also be defined as –

In the above declaration NULL character (\0) will automatically be inserted at the end of the string.

What is NULL Char “\0”?
‘\0’ represents the end of the string. It is also referred as String terminator & Null Character.

String I/O in C programming

Read & write Strings in C using Printf() and Scanf() functions

Note: %s format specifier is used for strings input/output

Read & Write Strings in C using gets() and puts() functions

C – String functions

C String function – strlen

size_t represents unsigned short
It returns the length of the string without including end character (terminating char ‘\0’).

Example of strlen:

strlen vs sizeof
strlen returns you the length of the string stored in array, however sizeof returns the total allocated size assigned to the array. So if I consider the above example again then the following statements would return the below values.

strlen(str1) returned value 13.
sizeof(str1) would return value 20 as the array size is 20 (see the first statement in main function).

C String function – strnlen

size_t represents unsigned short
It returns length of the string if it is less than the value specified for maxlen (maximum length) otherwise it returns maxlen value.

Example of strnlen:

Output:
Length of string str1 when maxlen is 30: 13
Length of string str1 when maxlen is 10: 10

Have you noticed the output of second printf statement, even though the string length was 13 it returned only 10 because the maxlen was 10.

C String function – strcmp

It compares the two strings and returns an integer value. If both the strings are same (equal) then this function would return 0 otherwise it may return a negative or positive value based on the comparison.

If string1 string2 then it would return positive value.
If string1 == string2 then you would get 0(zero) when you use this function for compare strings.

Example of strcmp:

Output:

C String function – strncmp

size_t is for unassigned short
It compares both the string till n characters or in other words it compares first n characters of both the strings.

Example of strncmp:

Output:

C String function – strcat

It concatenates two strings and returns the concatenated string.

Example of strcat:

Output:

C String function – strncat

It concatenates n characters of str2 to string str1. A terminator char (‘\0’) will always be appended at the end of the concatenated string.

Example of strncat:

Output:

C String function – strcpy

It copies the string str2 into string str1, including the end character (terminator char ‘\0’).

Example of strcpy:

Output:

C String function – strncpy

char *strncpy( char *str1, char *str2, size_t n)
size_t is unassigned short and n is a number.
Case1: If length of str2 > n then it just copies first n characters of str2 into str1.
Case2: If length of str2

Strings (C# Programming Guide)

A string is an object of type String whose value is text. Internally, the text is stored as a sequential read-only collection of Char objects. There is no null-terminating character at the end of a C# string; therefore a C# string can contain any number of embedded null characters (‘\0’). The Length property of a string represents the number of Char objects it contains, not the number of Unicode characters. To access the individual Unicode code points in a string, use the StringInfo object.

string vs. System.String

In C#, the string keyword is an alias for String. Therefore, String and string are equivalent, and you can use whichever naming convention you prefer. The String class provides many methods for safely creating, manipulating, and comparing strings. In addition, the C# language overloads some operators to simplify common string operations. For more information about the keyword, see string. For more information about the type and its methods, see String.

Declaring and Initializing Strings

You can declare and initialize strings in various ways, as shown in the following example:

Note that you do not use the new operator to create a string object except when initializing the string with an array of chars.

Initialize a string with the Empty constant value to create a new String object whose string is of zero length. The string literal representation of a zero-length string is «». By initializing strings with the Empty value instead of null, you can reduce the chances of a NullReferenceException occurring. Use the static IsNullOrEmpty(String) method to verify the value of a string before you try to access it.

Immutability of String Objects

String objects are immutable: they cannot be changed after they have been created. All of the String methods and C# operators that appear to modify a string actually return the results in a new string object. In the following example, when the contents of s1 and s2 are concatenated to form a single string, the two original strings are unmodified. The += operator creates a new string that contains the combined contents. That new object is assigned to the variable s1 , and the original object that was assigned to s1 is released for garbage collection because no other variable holds a reference to it.

Because a string «modification» is actually a new string creation, you must use caution when you create references to strings. If you create a reference to a string, and then «modify» the original string, the reference will continue to point to the original object instead of the new object that was created when the string was modified. The following code illustrates this behavior:

For more information about how to create new strings that are based on modifications such as search and replace operations on the original string, see How to modify string contents.

Regular and Verbatim String Literals

Use regular string literals when you must embed escape characters provided by C#, as shown in the following example:

Use verbatim strings for convenience and better readability when the string text contains backslash characters, for example in file paths. Because verbatim strings preserve new line characters as part of the string text, they can be used to initialize multiline strings. Use double quotation marks to embed a quotation mark inside a verbatim string. The following example shows some common uses for verbatim strings:

String Escape Sequences

Escape sequence	Character name	Unicode encoding
\’	Single quote	0x0027
\»	Double quote	0x0022
\\	Backslash	0x005C
\0	Null	0x0000
\a	Alert	0x0007
\b	Backspace	0x0008
\f	Form feed	0x000C
\n	New line	0x000A
\r	Carriage return	0x000D
\t	Horizontal tab	0x0009
\v	Vertical tab	0x000B
\u	Unicode escape sequence (UTF-16)	\uHHHH (range: 0000 — FFFF; example: \u00E7 = «Г§»)
\U	Unicode escape sequence (UTF-32)	\U00HHHHHH (range: 000000 — 10FFFF; example: \U0001F47D = «рџ‘Ѕ»)
\x	Unicode escape sequence similar to «\u» except with variable length	\xH[H][H][H] (range: 0 — FFFF; example: \x00E7 or \x0E7 or \xE7 = «Г§»)

When using the \x escape sequence and specifying less than 4 hex digits, if the characters that immediately follow the escape sequence are valid hex digits (i.e. 0-9, A-F, and a-f), they will be interpreted as being part of the escape sequence. For example, \xA1 produces «ВЎ», which is code point U+00A1. However, if the next character is «A» or «a», then the escape sequence will instead be interpreted as being \xA1A and produce «аЁљ», which is code point U+0A1A. In such cases, specifying all 4 hex digits (e.g. \x00A1 ) will prevent any possible misinterpretation.

At compile time, verbatim strings are converted to ordinary strings with all the same escape sequences. Therefore, if you view a verbatim string in the debugger watch window, you will see the escape characters that were added by the compiler, not the verbatim version from your source code. For example, the verbatim string @»C:\files.txt» will appear in the watch window as «C:\\files.txt».

Format Strings

A format string is a string whose contents are determined dynamically at runtime. Format strings are created by embedding interpolated expressions or placeholders inside of braces within a string. Everything inside the braces ( <. >) will be resolved to a value and output as a formatted string at runtime. There are two methods to create format strings: string interpolation and composite formatting.

String Interpolation

Available in C# 6.0 and later, interpolated strings are identified by the $ special character and include interpolated expressions in braces. If you are new to string interpolation, see the String interpolation — C# interactive tutorial for a quick overview.

Use string interpolation to improve the readability and maintainability of your code. String interpolation achieves the same results as the String.Format method, but improves ease of use and inline clarity.

Composite Formatting

The String.Format utilizes placeholders in braces to create a format string. This example results in similar output to the string interpolation method used above.

For more information on formatting .NET types see Formatting Types in .NET.

Substrings

A substring is any sequence of characters that is contained in a string. Use the Substring method to create a new string from a part of the original string. You can search for one or more occurrences of a substring by using the IndexOf method. Use the Replace method to replace all occurrences of a specified substring with a new string. Like the Substring method, Replace actually returns a new string and does not modify the original string. For more information, see How to search strings and How to modify string contents.

Accessing Individual Characters

You can use array notation with an index value to acquire read-only access to individual characters, as in the following example:

If the String methods do not provide the functionality that you must have to modify individual characters in a string, you can use a StringBuilder object to modify the individual chars «in-place», and then create a new string to store the results by using the StringBuilder methods. In the following example, assume that you must modify the original string in a particular way and then store the results for future use:

Null Strings and Empty Strings

An empty string is an instance of a System.String object that contains zero characters. Empty strings are used often in various programming scenarios to represent a blank text field. You can call methods on empty strings because they are valid System.String objects. Empty strings are initialized as follows:

By contrast, a null string does not refer to an instance of a System.String object and any attempt to call a method on a null string causes a NullReferenceException. However, you can use null strings in concatenation and comparison operations with other strings. The following examples illustrate some cases in which a reference to a null string does and does not cause an exception to be thrown:

Using StringBuilder for Fast String Creation

String operations in .NET are highly optimized and in most cases do not significantly impact performance. However, in some scenarios such as tight loops that are executing many hundreds or thousands of times, string operations can affect performance. The StringBuilder class creates a string buffer that offers better performance if your program performs many string manipulations. The StringBuilder string also enables you to reassign individual characters, something the built-in string data type does not support. This code, for example, changes the content of a string without creating a new string:

In this example, a StringBuilder object is used to create a string from a set of numeric types:

Strings, Extension Methods and LINQ

Because the String type implements IEnumerable , you can use the extension methods defined in the Enumerable class on strings. To avoid visual clutter, these methods are excluded from IntelliSense for the String type, but they are available nevertheless. You can also use LINQ query expressions on strings. For more information, see LINQ and Strings.

Читайте также:  Ноутбук dell windows 10 не выключается ноутбук