String String String String Constructors

Definition

Overloads

String(Char*) String(Char*) String(Char*)

유니코드 문자 배열에 대한 지정된 포인터가 가리키는 값으로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

String(Char[]) String(Char[]) String(Char[]) String(Char[])

유니코드 문자 배열에서 나타내는 값으로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*)

8비트 부호 있는 정수 배열에 대한 포인터가 나타내는 값으로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

지정한 횟수만큼 반복되는 지정된 유니코드 문자가 나타내는 값으로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

유니코드 문자 배열에 대한 지정된 포인터가 나타내는 값, 해당 배열 내의 시작 문자 위치 및 길이로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

유니코드 문자 배열에서 나타내는 값, 해당 배열 내의 시작 문자 위치 및 길이로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

8비트 부호 있는 정수 배열에 대한 지정된 포인터가 나타내는 값, 해당 배열 내의 시작 위치 및 길이로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

8비트 부호 있는 정수 배열에 대한 지정된 포인터가 나타내는 값, 해당 배열 내의 시작 문자 위치, 길이 및 String 개체로 Encoding 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Remarks

섹션 내용In this section:

오버 로드 된 생성자 구문 Overloaded constructor syntax
매개 변수 Parameters
예외 Exceptions
메서드 호출 합니까? Which method do I call?
문자열 만들기 Creating strings
반복적인 문자열 처리 Handling repetitive strings
인스턴스화하 문자열의 예:Examples of instantiating strings:
문자열 할당을 사용 하 여Using string assignment
문자 배열을 사용 하 여Using a character array
문자 배열의 일부를 사용 하 고 단일 문자를 반복 합니다.Using a portion of a character array and repeating a single character
문자 배열에 대 한 포인터를 사용 하 여Using a pointer to a character array
에 대 한 포인터 및 배열 범위를 사용 하 여Using a pointer and a range of an array
부호 있는 바이트 배열에 대 한 포인터를 사용 하 여Using a pointer to a signed byte array
버전 정보Version information

오버 로드 된 생성자 구문Overloaded constructor syntax

문자열 생성자 두 가지 범주로 나뉩니다: 포인터 매개 변수 없이 포인터 매개 변수를 사용 합니다.String constructors fall into two categories: those without pointer parameters, and those with pointer parameters. 포인터를 사용 하는 생성자는 CLS 규격이 아닙니다.The constructors that use pointers are not CLS-compliant. 또한 Visual Basic 포인터 사용을 지원 하지 않습니다 하 고 C# 코드를 사용 하 여 포인터 안전 하지 않은 컨텍스트에서 실행 해야 합니다.In addition, Visual Basic does not support the use of pointers, and C# requires code that uses pointers to run in an unsafe context. 자세한 내용은 unsafe를 참조하세요.For more information, see unsafe.

오버 로드를 선택 하면 추가 지침을 참조 하세요. 메서드 호출 합니까?For additional guidance on choosing an overload, see Which method do I call?

String(Char[] value)
유니코드 문자의 배열에 의해 표시 되는 값의 새 인스턴스를 초기화 합니다.Initializes the new instance to the value indicated by an array of Unicode characters. 유니코드 문자를 복사 하는이 생성자 (예제).This constructor copies Unicode characters(example).

String(Char[] value, Int32 startIndex, Int32 length)
길이 및 해당 배열 내의 시작 문자 위치를 유니코드 문자 배열에서 나타내는 값으로 새 인스턴스를 초기화 (예제).Initializes the new instance to the value indicated by an array of Unicode characters, a starting character position within that array, and a length (example).

String(Char c, Int32 count)
지정 된 유니코드 문자로 표시 된 값으로 새 인스턴스를 초기화 합니다. 지정된 된 횟수 만큼 반복 (예제).Initializes the new instance to the value indicated by a specified Unicode character repeated a specified number of times (example).

String(char* value)
(CLS 규격이 아닙니다.) Null 문자로 종료 되는 유니코드 문자의 배열에 대 한 포인터가 나타내는 값으로 새 인스턴스를 초기화 (u+0000 또는 '\0').(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of Unicode characters that is terminated by a null character (U+0000 or '\0'). (예제).(example).

권한: SecurityCriticalAttribute, 직접 실행 호출자에 대 한 완전 신뢰가 필요 합니다.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다.This member cannot be used by partially trusted or transparent code.

String(char* value, Int32 startIndex, Int32 length)
(CLS 규격이 아닙니다.) 유니코드 문자, 길이 및 해당 배열 내의 시작 문자 위치를 배열에 대 한 포인터가 가리키는 값으로 새 인스턴스를 초기화 합니다.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of Unicode characters, a starting character position within that array, and a length. 유니코드 문자를 복사 하는 생성자 value 인덱스부터 startIndex 인덱스에서 끝나는 startIndex + length – 1 (예제).The constructor copies the Unicode characters from value starting at index startIndex and ending at index startIndex + length – 1 (example).

권한: SecurityCriticalAttribute, 직접 실행 호출자에 대 한 완전 신뢰가 필요 합니다.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다.This member cannot be used by partially trusted or transparent code.

String(SByte* value)
(CLS 규격이 아닙니다.) 8 비트 부호 있는 정수 배열에 대 한 포인터가 나타내는 값으로 새 인스턴스를 초기화 합니다.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers. 배열 현재 시스템 코드 페이지를 사용 하 여 인코딩된 문자열을 나타내는 것으로 간주 됩니다 (즉, 지정한 인코딩을 Encoding.Default).The array is assumed to represent a string encoded using the current system code page (that is, the encoding specified by Encoding.Default). 문자를 처리 하는 생성자 value null 문자 (0x00)에 도달할 때까지 포인터에 의해 지정 된 위치에서 시작 (예제).The constructor processes characters from value starting from the location specified by the pointer until a null character (0x00) is reached (example).

권한: SecurityCriticalAttribute, 직접 실행 호출자에 대 한 완전 신뢰가 필요 합니다.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length)
(CLS 규격이 아닙니다.) 길이 및 해당 배열 내의 시작 위치, 8 비트 부호 있는 정수 배열에 대 한 포인터가 나타내는 값으로 새 인스턴스를 초기화 합니다.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers, a starting position within that array, and a length. 배열 현재 시스템 코드 페이지를 사용 하 여 인코딩된 문자열을 나타내는 것으로 간주 됩니다 (즉, 지정한 인코딩을 Encoding.Default).The array is assumed to represent a string encoded using the current system code page (that is, the encoding specified by Encoding.Default). 시작 하는 값에서 문자를 처리 하는 생성자 startIndex 에서 끝나는 startIndex + length – 1 (예제).The constructor processes characters from value starting at startIndex and ending at startIndex + length – 1 (example).

권한: SecurityCriticalAttribute, 직접 실행 호출자에 대 한 완전 신뢰가 필요 합니다.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(CLS 규격이 아닙니다.) 길이 해당 배열 내의 시작 위치를 8 비트 부호 있는 정수 배열에 대 한 포인터가 나타내는 값으로 새 인스턴스를 초기화 및 Encoding 개체입니다.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

권한: SecurityCriticalAttribute, 직접 실행 호출자에 대 한 완전 신뢰가 필요 합니다.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다.This member cannot be used by partially trusted or transparent code.

매개 변수Parameters

사용 하는 매개 변수의 전체 목록은 다음과 같습니다 String 포인터 매개 변수를 포함 하지 않는 생성자입니다.Here is a complete list of parameters used by String constructors that don't include a pointer parameter. 각 오버 로드에서 사용 하는 매개 변수를 위의 구문은 오버 로드를 참조 하세요.For the parameters used by each overload, see the overload syntax above.

매개 변수Parameter 형식Type 설명Description
value Char[]Char[] 유니코드 문자 배열입니다.An array of Unicode characters.
c Char 유니코드 문자입니다.A Unicode character.
startIndex Int32 시작 위치 value 새 문자열의 첫 번째 문자입니다.The starting position in value of the first character in the new string.

기본값: 0Default value: 0
length Int32 문자 수가 value 새 문자열에 포함 합니다.The number of characters in value to include in the new string.

기본값: Array.Length Default value: Array.Length
count Int32 횟수 문자 c 새 문자열에서 반복 됩니다.The number of times the character c is repeated in the new string. 하는 경우 count 가 0 이면 새 개체의 값은 String.Empty합니다.If count is zero, the value of the new object is String.Empty.

사용 하는 매개 변수의 전체 목록은 다음과 같습니다 String 포인터 매개 변수를 포함 하는 생성자입니다.Here is a complete list of parameters used by String constructors that include a pointer parameter. 각 오버 로드에서 사용 하는 매개 변수를 위의 구문은 오버 로드를 참조 하세요.For the parameters used by each overload, see the overload syntax above.

매개 변수Parameter 형식Type 설명Description
value Char*

또는-or-

SByte*
유니코드 문자를 null로 끝나는 배열 또는 8 비트 부호 있는 정수 배열에 대 한 포인터입니다.A pointer to a null-terminated array of Unicode characters or an array of 8-bit signed integers. 하는 경우 value 됩니다 null 이거나 빈 배열이 면 새 문자열의 값이 String.Empty합니다.If value is null or an empty array, the value of the new string is String.Empty.
startIndex Int32 새 문자열에서 첫 번째 문자를 정의 하는 배열 요소의 인덱스입니다.The index of the array element that defines the first character in the new string.

기본값: 0Default value: 0
length Int32 새 문자열을 만드는 데 사용 되는 배열 요소의 수입니다.The number of array elements to use to create the new string. 길이가 0 인 경우 생성자 값인 문자열을 만듭니다. String.Empty합니다.If length is zero, the constructor creates a string whose value is String.Empty.

기본값: Array.Length Default value: Array.Length
enc Encoding 지정 하는 개체를 어떻게 value 배열 인코딩됩니다.An object that specifies how the value array is encoded.

기본값: Encoding.Default, 또는 시스템의 현재 ANSI 코드 페이지Default value: Encoding.Default, or the system's current ANSI code page

예외Exceptions

포인터 매개 변수를 포함 하지 않는 생성자에서 throw 된 예외 목록은 다음과 같습니다.Here's a list of exceptions thrown by constructors that don't include pointer parameters.

예외Exception 조건Condition throwThrown by
ArgumentNullException valuenull인 경우value is null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndexlength, 또는 count 가 0 보다 작습니다.startIndex,length, or count is less than zero.

또는-or-

startIndexlength의 합계가 value의 요소 수보다 큽니다.The sum of startIndex and length is greater than the number of elements in value.

또는-or-

count가 0보다 작은 경우count is less than zero.
String(Char, Int32)

String(Char[], Int32, Int32)

포인터 매개 변수를 포함 하는 생성자에서 throw 된 예외 목록은 다음과 같습니다.Here's a list of exceptions thrown by constructors that include pointer parameters.

예외Exception 조건Condition throwThrown by
ArgumentException value 잘못 된 유니코드 문자가 포함 된 배열을 지정 합니다.value specifies an array that contains an invalid Unicode character.

또는-or-

value 또는 value + startIndex 있는 64k 보다 작은 주소를 지정 합니다.value or value + startIndex specifies an address that is less than 64K.

또는-or-

String 에서 인스턴스를 초기화 하지 못했습니다 합니다 value 때문에 바이트 배열 value 기본 코드 페이지 인코딩을 사용 하지 않습니다.A new String instance could not be initialized from the value byte array because value does not use the default code page encoding.
포인터를 사용 하 여 모든 생성자입니다.All constructors with pointers.
ArgumentNullException value가 null인 경우value is null. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException 현재 프로세스에 주소가 지정된 모든 문자에 대한 읽기 액세스 권한이 있는 것은 아닙니다.The current process does not have read access to all the addressed characters.

또는-or-

startIndex 또는 length가 0보다 작거나 value + startIndex로 인해 포인터 오버플로가 발생하거나, 현재 프로세스에서 주소가 지정된 모든 문자에 대한 읽기 액세스 권한을 갖지는 않습니다.startIndex or length is less than zero, value + startIndex cause a pointer overflow, or the current process does not have read access to all the addressed characters.

또는-or-

새 문자열의 길이가 너무 커서 할당할 수 있습니다.The length of the new string is too large to allocate.
포인터를 사용 하 여 모든 생성자입니다.All constructors with pointers.
AccessViolationException value또는 value + startIndex + length – 1, 잘못 된 주소를 지정 합니다.value, or value + startIndex + length – 1, specifies an invalid address. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

메서드 호출 합니까?Which method do I call?

대상To 호출 또는 사용Call or use
문자열을 만듭니다.Create a string. 기존 문자열 또는 문자열 리터럴을 할당 (예제)Assignment from a string literal or an existing string (example)
전체 문자 배열에서 문자열을 만듭니다.Create a string from an entire character array. String(Char[]) (예제)String(Char[]) (example)
일부 문자 배열에서 문자열을 만듭니다.Create a string from a portion of a character array. String(Char[], Int32, Int32) (예제)String(Char[], Int32, Int32) (example)
같은 문자를 여러 번 반복 하는 문자열을 만듭니다.Create a string that repeats the same character multiple times. String(Char, Int32) (예제)String(Char, Int32) (example)
유니코드 또는 와이드 문자 배열에 대 한 포인터에서 문자열을 만듭니다.Create a string from a pointer to a Unicode or wide character array. String(Char*)
해당 포인터를 사용 하 여 부분으로 된 유니코드 또는 와이드 문자 배열에서 문자열을 만듭니다.Create a string from a portion of a Unicode or wide character array by using its pointer. String(Char*, Int32, Int32)
C + +에서 문자열을 만들려면 char 배열입니다.Create a string from a C++ char array. String(SByte*), String(SByte*, Int32, Int32)String(SByte*), String(SByte*, Int32, Int32)

또는-or-

String(SByte*, Int32, Int32, Encoding)
ASCII 문자에서 문자열을 만듭니다.Create a string from ASCII characters. ASCIIEncoding.GetString

문자열 만들기Creating strings

가장 일반적으로 사용 되는 기법에 문자열을 프로그래밍 방식으로 만드는 단순한 할당을에 설명 된 대로 이 예제에서는합니다.The most commonly used technique for creating strings programmatically is simple assignment, as illustrated in this example. String 클래스에 네 가지 유형의 다음 값 중에서 문자열을 만들 수 있도록 하는 생성자 오버 로드도 포함 되어 있습니다.The String class also includes four types of constructor overloads that let you create strings from the following values:

  • 문자 배열 (u t F-16으로 인코딩된 문자 배열)입니다.From a character array (an array of UTF-16-encoded characters). 새로 만들 수 있습니다 String 개체에서 배열 전체 또는 그 일부에 있는 문자입니다.You can create a new String object from the characters in the entire array or a portion of it. String(Char[]) 생성자 새 문자열을 배열에 있는 모든 문자를 복사 합니다.The String(Char[]) constructor copies all the characters in the array to the new string. String(Char[], Int32, Int32) 인덱스에서 문자를 복사 하는 생성자 startIndex 인덱스로 startIndex + length – 새 문자열을 1입니다.The String(Char[], Int32, Int32) constructor copies the characters from index startIndex to index startIndex + length – 1 to the new string. 하는 경우 length 가 0 인 새 문자열의 값은 String.Empty합니다.If length is zero, the value of the new string is String.Empty.

    코드 반복적으로 동일한 값이 있는 문자열을 인스턴스화하는 경우 문자열을 작성 하는 대체 방법을 사용 하 여 응용 프로그램 성능을 개선할 수 있습니다.If your code repeatedly instantiates strings that have the same value, you can improve application performance by using an alternate means of creating strings. 자세한 내용은 반복적인 문자열 처리합니다.For more information, see Handling repetitive strings.

  • 단일에서 문자를 한 번 이상를 사용 하 여 중복 된 0은 String(Char, Int32) 생성자입니다.From a single character that is duplicated zero, one, or more times, by using the String(Char, Int32) constructor. 하는 경우 count 가 0 인 새 문자열의 값은 String.Empty합니다.If count is zero, the value of the new string is String.Empty.

  • null로 끝나는 문자 배열에 대 한 포인터를 사용 합니다 String(Char*) 또는 String(Char*, Int32, Int32) 생성자입니다.From a pointer to a null-terminated character array, by using the String(Char*) or String(Char*, Int32, Int32) constructor. 전체 배열 또는 지정된 된 범위 수 데 사용할 문자열을 초기화 합니다.Either the entire array or a specified range can be used to initialize the string. 생성자는 지정된 된 포인터가 더하기 또는 지정된 된 포인터에서 시작 하는 유니코드 문자의 시퀀스를 복사 startIndex 또는 배열의 끝까지 계속 length 문자입니다.The constructor copies a sequence of Unicode characters starting from the specified pointer or from the specified pointer plus startIndex and continuing to the end of the array or for length characters. 하는 경우 value 가 null 포인터 또는 length 가 0 이면 생성자 값인 문자열을 만듭니다 String.Empty합니다.If value is a null pointer or length is zero, the constructor creates a string whose value is String.Empty. 배열의 끝에 복사 작업이 진행 하 고 null로 끝나는 배열 하지 않는 경우 생성자 동작은 시스템에 따라 다릅니다.If the copy operation proceeds to the end of the array and the array is not null-terminated, the constructor behavior is system-dependent. 이러한 조건이 액세스 위반이 발생할 수 있습니다.Such a condition might cause an access violation.

    배열에 포함 된 null 문자가 포함 된 경우 (u+0000 또는 '\0') 및 String(Char*, Int32, Int32) 오버 로드 호출 되 면 포함 된 문자열 인스턴스 length 문자를 포함 하 여 null을 포함 합니다.If the array contains any embedded null characters (U+0000 or '\0') and the String(Char*, Int32, Int32) overload is called, the string instance contains length characters including any embedded nulls. 다음 예제에서는 두 개의 null 문자를 포함 하는 요소가 10 개인 배열에 대 한 포인터에 전달 될 때 일어나는 String(Char*, Int32, Int32) 메서드.The following example shows what happens when a pointer to an array of 10 elements that includes two null characters is passed to the String(Char*, Int32, Int32) method. 주소는 배열의 시작 부분 문자열에 추가할 배열의 모든 요소 이기 때문에 생성자 내장된 된 null이 두 가지를 포함 하는 10 개의 문자를 사용 하 여 문자열을 인스턴스화합니다.Because the address is the beginning of the array and all elements in the array are to be added to the string, the constructor instantiates a string with ten characters, including two embedded nulls. 반면, 동일한 배열을 전달 하는 경우는 String(Char*) 생성자의 결과 첫 번째 null 문자를 포함 하지 않는 4 자의 문자열입니다.On the other hand, if the same array is passed to the String(Char*) constructor, the result is a four-character string that does not include the first null character.

    using namespace System;
    
    void main()
    {
       wchar_t chars[] = { L'a', L'b', L'c', L'd', L'\0', L'A', L'B', 
                           L'C', L'D', L'\0' };
       Char* chPtr = chars;
       String^ s = gcnew String(chPtr, 0, 
                                sizeof(chars) / sizeof (wchar_t));            
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();
       
       s = gcnew String(chPtr);         
       
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();    
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    
    using System;
    
    public class Example
    {
       public unsafe static void Main()
       {
          char[] chars = { 'a', 'b', 'c', 'd', '\0', 'A', 'B', 'C', 'D', '\0' };
          string s = null;
          
          fixed(char* chPtr = chars) {
             s = new string(chPtr, 0, chars.Length);            
          } 
    
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();
          
          fixed(char* chPtr = chars) {
             s = new string(chPtr);         
          }
          
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();    
       }
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    

    배열의는 유니코드 문자를 포함 해야 합니다.The array must contain Unicode characters. 문자 배열 되도록 즉 c + +에서 관리 되는 것으로 정의 하거나 Char형식 또는 관리 되지 않는wchar_t형식입니다.In C++, this means that the character array must be defined either as the managed Char[] type or the unmanagedwchar_t[] type.

    경우는 String(Char*) 오버 로드 호출 되 고 때 배열의 null로 종료 하지 않은 경우는 String(Char*, Int32, Int32) 오버 로드가 호출 됩니다 및 startIndex + length외부 메모리를 할당 된 문자 시퀀스에 대 한 범위를 포함 하는-1 생성자의 동작은 시스템에 종속 된 및 액세스 위반이 발생할 수 있습니다.If the String(Char*) overload is called and the array is not null-terminated, or if the String(Char*, Int32, Int32) overload is called and startIndex + length-1 includes a range that it outside the memory allocated for the sequence of characters, the behavior of the constructor is system-dependent, and an access violation may occur. 또한 Intel Itanium 프로세서에 호출을 String(Char*, Int32, Int32) 생성자가 throw 될 수 있습니다는 DataMisalignedException 예외입니다.In addition, on the Intel Itanium processor, calls to the String(Char*, Int32, Int32) constructor may throw a DataMisalignedException exception. 이 경우 호출 된 String(Char[], Int32, Int32) 대신 합니다.If this occurs, call the String(Char[], Int32, Int32) instead.

  • 부호 있는 바이트 배열에 대 한 포인터입니다.From a pointer to a signed byte array. 전체 배열 또는 지정된 된 범위 수 데 사용할 문자열을 초기화 합니다.Either the entire array or a specified range can be used to initialize the string. 인코딩 기본 코드 페이지를 사용 하 여 바이트 시퀀스를 해석할 수 있습니다 또는 생성자 호출에서 인코딩을 지정할 수 있습니다.The sequence of bytes can be interpreted by using the default code page encoding, or an encoding can be specified in the constructor call. 생성자를 null로 종료 되지 않는 전체 배열에서 문자열을 인스턴스화하려고 시도 아니면에서 배열의 범위 value + startIndex 하려면 value + startIndex + length 배열에 대해 할당 된 메모리 외부-1은,이 생성자의 동작은 시스템에 종속 된 및 액세스 위반이 발생할 수 있습니다.If the constructor tries to instantiate a string from an entire array that is not null-terminated, or if the range of the array from value + startIndex to value + startIndex + length -1 is outside of the memory allocated for the array, the behavior of this constructor is system-dependent, and an access violation may occur.

    부호 있는 바이트 배열을 매개 변수로 포함 하는 세 가지 생성자는 주로 c + +를 변환할 설계 char 이 예와 같이 문자열로 배열:The three constructors that include a signed byte array as a parameter are designed primarily to convert a C++ char array to a string, as shown in this example:

    using namespace System;
    
    void main()
    {
          char chars[] = { 'a', 'b', 'c', 'd', '\x00' };
          
          char* charPtr = chars;
          String^ value = gcnew String(charPtr);
    
          Console::WriteLine(value);
    }
    // The example displays the following output:
    //      abcd
    

    값이 0 인 모든 null 문자 ('\0') 또는 바이트 배열에 있는 경우와 String(SByte*, Int32, Int32) 오버 로드 호출 되 면 포함 된 문자열 인스턴스 length 문자를 포함 하 여 null을 포함 합니다.If the array contains any null characters ('\0') or bytes whose value is 0 and the String(SByte*, Int32, Int32) overload is called, the string instance contains length characters including any embedded nulls. 다음 예제에서는 두 개의 null 문자를 포함 하는 요소가 10 개인 배열에 대 한 포인터에 전달 될 때 일어나는 String(SByte*, Int32, Int32) 메서드.The following example shows what happens when a pointer to an array of 10 elements that includes two null characters is passed to the String(SByte*, Int32, Int32) method. 주소는 배열의 시작 부분 문자열에 추가할 배열의 모든 요소 이기 때문에 생성자 내장된 된 null이 두 가지를 포함 하는 10 개의 문자를 사용 하 여 문자열을 인스턴스화합니다.Because the address is the beginning of the array and all elements in the array are to be added to the string, the constructor instantiates a string with ten characters, including two embedded nulls. 반면, 동일한 배열을 전달 하는 경우는 String(SByte*) 생성자의 결과 첫 번째 null 문자를 포함 하지 않는 4 자의 문자열입니다.On the other hand, if the same array is passed to the String(SByte*) constructor, the result is a four-character string that does not include the first null character.

    using namespace System;
    
    void main()
    {
       char bytes[] = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42,0x43, 
                        0x44, 0x00 };
       
       char* bytePtr = bytes;
       String^ s = gcnew String(bytePtr, 0, sizeof(bytes) / sizeof (char));
       
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       
       Console::WriteLine();
       
       s = gcnew String(bytePtr);
    
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();       
    }
    // The example displays the following output:
    //      0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //      0061 0062 0063 0064
    
    using System;
    
    public class Example
    {
       public unsafe static void Main()
       {
          sbyte[] bytes = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42,0x43, 0x44, 0x00 };
          
          string s = null;
          fixed (sbyte* bytePtr = bytes) {
             s = new string(bytePtr, 0, bytes.Length);
          }
          
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          
          Console.WriteLine();    
    
          fixed(sbyte* bytePtr = bytes) {
             s = new string(bytePtr);         
          }
          
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();    
    
       }
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    

    때문에 합니다 String(SByte*) 하 고 String(SByte*, Int32, Int32) 생성자 해석 value 기본 ANSI 코드 페이지를 사용 하 여 동일한 바이트 배열 사용 하는 이러한 생성자를 호출 합니다. 만들 수 있습니다 다른 시스템에서 다른 값이 있는 문자열입니다.Because the String(SByte*) and String(SByte*, Int32, Int32) constructors interpret value by using the default ANSI code page, calling these constructors with identical byte arrays may create strings that have different values on different systems.

반복적인 문자열 처리Handling repetitive strings

구문 분석 하거나 자주 스트림의 텍스트를 디코딩하는 앱을 사용 합니다 String(Char[], Int32, Int32) 생성자 또는 StringBuilder.Append(Char[], Int32, Int32) 문자의 시퀀스를 문자열로 변환 하는 방법입니다.Apps that parse or decode streams of text often use the String(Char[], Int32, Int32) constructor or the StringBuilder.Append(Char[], Int32, Int32) method to convert sequences of characters into a string. 반복적으로 만들고 하나의 문자열을 다시 사용 하는 대신 동일한 값을 사용 하 여 새 문자열 만들기 메모리가 낭비 되 고 있습니다.Repeatedly creating new strings with the same value instead of creating and reusing one string wastes memory. 동일한 문자열 값을 반복적으로 호출 하 여 만들 수 있는 경우는 String(Char[], Int32, Int32) 생성자에서 알 수 없는 경우에 이동 수 있는 이러한 동일한 문자열 값을 조회 테이블을 대신 사용할 수 있습니다.If you are likely to create the same string value repeatedly by calling the String(Char[], Int32, Int32) constructor, even if you don't know in advance what those identical string values may be, you can use a lookup table instead.

예를 들어 읽고 XML 태그 및 특성을 포함 하는 파일에서 문자 스트림 구문 분석 합니다.For example, suppose you read and parse a stream of characters from a file that contains XML tags and attributes. 스트림을 구문 분석 하는 경우 특정 토큰 (즉, 기호화 된 의미가 있는 문자 시퀀스) 반복적으로 발생 합니다.When you parse the stream, you repeatedly encounter certain tokens (that is, sequences of characters that have a symbolic meaning). "0", "1", "true" 및 "false" 문자열에 해당 하는 토큰은 XML 스트림에서 자주 발생할 수 있습니다.Tokens equivalent to the strings "0", "1", "true", and "false" are likely to occur frequently in an XML stream.

각 토큰으로 새 문자열로 변환 하는 대신 만들 수 있습니다는 System.Xml.NameTable 일반적으로 발생 하는 문자열을 저장 하는 개체입니다.Instead of converting each token into a new string, you can create a System.Xml.NameTable object to hold commonly occurring strings. NameTable 개체 임시 메모리를 할당 하지 않고 저장 된 문자열을 검색 하므로 성능이 향상 됩니다.The NameTable object improves performance, because it retrieves stored strings without allocating temporary memory. 사용 하 여 토큰을 발생 하는 경우는 NameTable.Get(Char[], Int32, Int32) 테이블에서 토큰을 검색 하는 방법입니다.When you encounter a token, use the NameTable.Get(Char[], Int32, Int32) method to retrieve the token from the table. 토큰이 있으면 메서드는 해당 문자열을 반환 합니다.If the token exists, the method returns the corresponding string. 토큰 존재 하지 않는 경우 사용 하 여를 NameTable.Add(Char[], Int32, Int32) 메서드 테이블을 사용 하 여 토큰을 삽입 하는 데 해당 문자열을 가져옵니다.If the token does not exist, use the NameTable.Add(Char[], Int32, Int32) method to insert the token into the table and to get the corresponding string.

문자열 할당을 사용 하는 예 1:Example 1: Using string assignment

다음 예제에서는 문자열 리터럴을 할당 하 여 새 문자열을 만듭니다.The following example creates a new string by assigning it a string literal. 두 번째 문자열에 첫 번째 문자열의 값을 할당 하 여 만듭니다.It creates a second string by assigning the value of the first string to it. 이 두 가지 가장 일반적인 새 String 개체입니다.These are the two most common ways to instantiate a new String object.

using namespace System;

void main()
{
   String^ value1 = L"This is a string.";
   String^ value2 = value1;
   Console::WriteLine(value1);
   Console::WriteLine(value2);
}
// The example displays the following output:
//    This is a string.
//    This is a string.
using System;

public class Example
{
   public static void Main()
   {
      String value1 = "This is a string.";
      String value2 = value1;
      Console.WriteLine(value1);
      Console.WriteLine(value2);
   }
}
// The example displays the following output:
//    This is a string.
//    This is a string.
Module Example
   Public Sub Main()
      Dim value1 As String = "This is a string."
      Dim value2 As String = value1
      Console.WriteLine(value1)
      Console.WriteLine(value2)
   End Sub
End Module
' The example displays the following output:
'    This is a string.
'    This is a string.

예제 2: 문자 배열 사용Example 2: Using a character array

다음 예제에서는 새 String 문자 배열에서 개체입니다.The following example demonstrates how to create a new String object from a character array.

// Unicode Mathematical operators
wchar_t charArray1[4] = {L'\x2200',L'\x2202',L'\x200F',L'\x2205'};
wchar_t * lptstr1 =  &charArray1[ 0 ];
String^ wszMathSymbols = gcnew String( lptstr1 );

// Unicode Letterlike Symbols
wchar_t charArray2[4] = {L'\x2111',L'\x2118',L'\x2122',L'\x2126'};
wchar_t * lptstr2 =  &charArray2[ 0 ];
String^ wszLetterLike = gcnew String( lptstr2 );

// Compare Strings - the result is false
Console::WriteLine( String::Concat( L"The Strings are equal? ", (0 == String::Compare( wszLetterLike, wszMathSymbols ) ? (String^)"TRUE" : "FALSE") ) );
// Unicode Mathematical operators
char [] charArr1 = {'\u2200','\u2202','\u200F','\u2205'};
String szMathSymbols = new String(charArr1);

// Unicode Letterlike Symbols
char [] charArr2 = {'\u2111','\u2118','\u2122','\u2126'};
String szLetterLike = new String (charArr2);

// Compare Strings - the result is false
Console.WriteLine("The Strings are equal? " +
    (String.Compare(szMathSymbols, szLetterLike)==0?"true":"false") );
' Unicode Mathematical operators
Dim charArr1() As Char = {ChrW(&H2200), ChrW(&H2202), _
                          ChrW(&H200F), ChrW(&H2205)}
Dim szMathSymbols As New String(charArr1)

' Unicode Letterlike Symbols
Dim charArr2() As Char = {ChrW(&H2111), ChrW(&H2118), _
                          ChrW(&H2122), ChrW(&H2126)}
Dim szLetterLike As New String(charArr2)

' Compare Strings - the result is false
Console.WriteLine("The strings are equal? " & _
        CStr(szMathSymbols.Equals(szLetterLike))) 

예제 3: 문자 배열의 일부를 사용 하 고 단일 문자를 반복 합니다.Example 3: Using a portion of a character array and repeating a single character

다음 예제에서는 새로 만드는 방법을 보여 줍니다 String 개체를 만들기 위한 방법과 문자 배열에 부분에서 String 단일 문자를 여러 번 포함 하는 개체입니다.The following example demonstrates how to create a new String object from a portion of a character array, and how to create a new String object that contains multiple occurrences of a single character.

// Create a Unicode String with 5 Greek Alpha characters
String^ szGreekAlpha = gcnew String( L'\x0391',5 );

// Create a Unicode String with a Greek Omega character
wchar_t charArray5[3] = {L'\x03A9',L'\x03A9',L'\x03A9'};
String^ szGreekOmega = gcnew String( charArray5,2,1 );
String^ szGreekLetters = String::Concat( szGreekOmega, szGreekAlpha, szGreekOmega->Clone() );

// Examine the result
Console::WriteLine( szGreekLetters );

// The first index of Alpha
int ialpha = szGreekLetters->IndexOf( L'\x0391' );

// The last index of Omega
int iomega = szGreekLetters->LastIndexOf( L'\x03A9' );
Console::WriteLine( String::Concat(  "The Greek letter Alpha first appears at index ", Convert::ToString( ialpha ) ) );
Console::WriteLine( String::Concat(  " and Omega last appears at index ", Convert::ToString( iomega ),  " in this String." ) );
// Create a Unicode String with 5 Greek Alpha characters
String szGreekAlpha = new String('\u0391',5);
// Create a Unicode String with a Greek Omega character
String szGreekOmega = new String(new char [] {'\u03A9','\u03A9','\u03A9'},2,1);

String szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone());

// Examine the result
Console.WriteLine(szGreekLetters);

// The first index of Alpha
int ialpha = szGreekLetters.IndexOf('\u0391');
// The last index of Omega
int iomega = szGreekLetters.LastIndexOf('\u03A9');

Console.WriteLine("The Greek letter Alpha first appears at index " + ialpha +
    " and Omega last appears at index " + iomega + " in this String.");
' Create a Unicode String with 5 Greek Alpha characters
Dim szGreekAlpha As New String(ChrW(&H0391), 5)
' Create a Unicode String with a Greek Omega character
Dim szGreekOmega As New String(New Char() {ChrW(&H03A9), ChrW(&H03A9), _
                                           ChrW(&H03A9)}, 2, 1)

Dim szGreekLetters As String = String.Concat(szGreekOmega, szGreekAlpha, _
                                             szGreekOmega.Clone())

' Examine the result
Console.WriteLine(szGreekLetters)

' The first index of Alpha
Dim iAlpha As Integer = szGreekLetters.IndexOf(ChrW(&H0391))
' The last index of Omega
Dim iomega As Integer = szGreekLetters.LastIndexOf(ChrW(&H03A9))

Console.WriteLine("The Greek letter Alpha first appears at index {0}.", _ 
                  ialpha)
Console.WriteLIne("The Greek letter Omega last appears at index {0}.", _
                  iomega)

예제 4: 문자 배열에 대 한 포인터를 사용 하 여Example 4: Using a pointer to a character array

다음 예제에서는 새 String 문자의 배열에 대 한 포인터에서 개체입니다.The following example demonstrates how to create a new String object from a pointer to an array of characters. C# 예제를 사용 하 여 컴파일해야 합니다 /unsafe 컴파일러 스위치입니다.The C# example must be compiled by using the /unsafe compiler switch.

using namespace System;

void main()
{
   wchar_t characters[] = {L'H',L'e',L'l',L'l',L'o',L' ', 
                           L'W',L'o',L'r',L'l',L'd',L'!',L'\x0000'};

   Char* charPtr = characters;
   String^ value = gcnew String(charPtr);
   Console::WriteLine(value);
}
// The example displays the following output:
//        Hello world!
using System;

public class Example
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      string value;
      
      fixed (char* charPtr = characters) {
         value = new String(charPtr);
      }                            
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//        Hello world!

예제 5: 포인터 및 배열 범위에서 문자열로 인스턴스화Example 5: Instantiating a string from a pointer and a range of an array

다음 예제에서는 마침표 또는 느낌표를 문자 배열의 요소를 검사합니다.The following example examines the elements of a character array for either a period or an exclamation point. 을 찾으면 문장 부호 기호가 앞에 있는 배열의 문자에서 문자열을 인스턴스화합니다.If one is found, it instantiates a string from the characters in the array that precede the punctuation symbol. 그렇지 않은 경우 문자열 배열의 전체 내용으로 인스턴스화합니다.If not, it instantiates a string with the entire contents of the array. C# 예제를 사용 하 여 컴파일해야 합니다 /unsafe 컴파일러 스위치입니다.The C# example must be compiled using the /unsafe compiler switch.

using namespace System;


void main()
{
   wchar_t characters[] = {L'H',L'e',L'l',L'l',L'o',L' ', 
                           L'W',L'o',L'r',L'l',L'd',L'!',L'\x0000'};

   Char* charPtr = characters;
   int length = 0;
   Char* iterator = charPtr;

   while (*iterator != '\x0000')
   {
      if (*iterator == L'!' || *iterator == L'.')
         break;
      *iterator++;
      length++;
   }
   String^ value = gcnew String(charPtr, 0, length);
   Console::WriteLine(value);
}
// The example displays the following output:
//      Hello World
using System;

public class Example
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      String value;
      
      fixed (char* charPtr = characters) {
         int length = 0;
         Char* iterator = charPtr;
   
         while (*iterator != '\x0000')
         {
            if (*iterator == '!' || *iterator == '.')
               break;
            iterator++;
            length++;
         }
         value = new String(charPtr, 0, length);
      }
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//      Hello World

예제 6: 부호 있는 바이트 배열에 대 한 포인터에서 문자열을 인스턴스화Example 6: Instantiating a string from a pointer to a signed byte array

다음 예제에서는 어떻게의 인스턴스를 만들 수 있습니다 합니다 String 클래스는 String(SByte*) 생성자입니다.The following example demonstrates how you can create an instance of the String class with the String(SByte*) constructor.

// Null terminated ASCII characters in a simple char array
char charArray3[4] = {0x41,0x42,0x43,0x00};
char * pstr3 =  &charArray3[ 0 ];
String^ szAsciiUpper = gcnew String( pstr3 );
char charArray4[4] = {0x61,0x62,0x63,0x00};
char * pstr4 =  &charArray4[ 0 ];
String^ szAsciiLower = gcnew String( pstr4,0,sizeof(charArray4) );

// Prints "ABC abc"
Console::WriteLine( String::Concat( szAsciiUpper,  " ", szAsciiLower ) );

// Compare Strings - the result is true
Console::WriteLine( String::Concat(  "The Strings are equal when capitalized ? ", (0 == String::Compare( szAsciiUpper->ToUpper(), szAsciiLower->ToUpper() ) ? (String^)"TRUE" :  "FALSE") ) );

// This is the effective equivalent of another Compare method, which ignores case
Console::WriteLine( String::Concat(  "The Strings are equal when capitalized ? ", (0 == String::Compare( szAsciiUpper, szAsciiLower, true ) ? (String^)"TRUE" :  "FALSE") ) );
unsafe
{
    // Null terminated ASCII characters in an sbyte array
    String szAsciiUpper = null;
    sbyte[] sbArr1 = new sbyte[] { 0x41, 0x42, 0x43, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiUpper = sbArr1)
    {
        szAsciiUpper = new String(pAsciiUpper);
    }
    String szAsciiLower = null;
    sbyte[] sbArr2 = { 0x61, 0x62, 0x63, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiLower = sbArr2)
    {
        szAsciiLower = new String(pAsciiLower, 0, sbArr2.Length);
    }
    // Prints "ABC abc"
    Console.WriteLine(szAsciiUpper + " " + szAsciiLower);

    // Compare Strings - the result is true
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper())==0?"true":"false") );

    // This is the effective equivalent of another Compare method, which ignores case
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper, szAsciiLower, true)==0?"true":"false") );
}

버전 정보Version information

.NET Framework.NET Framework
모든 오버 로드에 지원 됩니다: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0All overloads are supported in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile.NET Framework Client Profile
모든 오버 로드에 지원 됩니다: 4, 3.5 SP1All overloads are supported in: 4, 3.5 SP1

이식 가능한 클래스 라이브러리Portable Class Library
없이 모든 오버 로드는 SByte * 매개 변수는 지원All overloads without an SByte* parameter are supported

Windows 스토어 앱용 .NET.NET for Windows Store apps
없이 모든 오버 로드는 SByte * 매개 변수에서 지원 됩니다: Windows 8All overloads without an SByte* parameter are supported in: Windows 8

String(Char*) String(Char*) String(Char*)

중요

This API is not CLS-compliant.

유니코드 문자 배열에 대한 지정된 포인터가 가리키는 값으로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

public:
 String(char* value);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (char* value);
new string : nativeptr<char> -> string

매개 변수

value
Char*

null로 끝나는 유니코드 문자 배열에 대한 포인터입니다. A pointer to a null-terminated array of Unicode characters.

Exceptions

현재 프로세스에 주소가 지정된 모든 문자에 대한 읽기 액세스 권한이 있는 것은 아닙니다. The current process does not have read access to all the addressed characters.

value는 잘못된 유니코드 문자가 포함된 배열을 지정하거나 value가 64000보다 작은 주소를 지정합니다. value specifies an array that contains an invalid Unicode character, or value specifies an address less than 64000.

Remarks

참고

이 및 기타에 대 한 포괄적인 사용 정보와 예제 String 생성자 오버 로드를 참조 합니다 String 생성자 요약 합니다.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Security

SecurityCriticalAttribute
직접 실행 호출자에 대 한 완전 신뢰가 필요 합니다. requires full trust for the immediate caller. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다. This member cannot be used by partially trusted or transparent code.

String(Char[]) String(Char[]) String(Char[]) String(Char[])

유니코드 문자 배열에서 나타내는 값으로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

public:
 String(cli::array <char> ^ value);
public String (char[] value);
new string : char[] -> string
Public Sub New (value As Char())

매개 변수

value
Char[]

유니코드 문자 배열입니다. An array of Unicode characters.

Remarks

참고

이 및 기타에 대 한 포괄적인 사용 정보와 예제 String 생성자 오버 로드를 참조 합니다 String 생성자 요약 합니다.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)

public:
 String(ReadOnlySpan<char> value);
public String (ReadOnlySpan<char> value);
new string : ReadOnlySpan<char> -> string
Public Sub New (value As ReadOnlySpan(Of Char))

매개 변수

String(SByte*) String(SByte*) String(SByte*)

중요

This API is not CLS-compliant.

8비트 부호 있는 정수 배열에 대한 포인터가 나타내는 값으로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

public:
 String(System::SByte* value);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value);
new string : nativeptr<sbyte> -> string

매개 변수

value
SByte*

null로 끝나는 8비트 부호 있는 정수 배열에 대한 포인터입니다. A pointer to a null-terminated array of 8-bit signed integers. 정수는 현재 시스템 코드 페이지 인코딩(즉, Default로 지정된 인코딩)을 사용하여 해석됩니다. The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

Exceptions

value가 ANSI로 인코딩되었다고 가정하고 String의 새 인스턴스를 value를 사용하여 초기화할 수 없습니다. A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

value의 null 종결 문자로 결정되는 초기화할 새 문자열의 길이가 너무 커서 할당할 수 없습니다. The length of the new string to initialize, which is determined by the null termination character of value, is too large to allocate.

value가 잘못된 주소를 지정합니다. value specifies an invalid address.

Remarks

참고

이 및 기타에 대 한 포괄적인 사용 정보와 예제 String 생성자 오버 로드를 참조 합니다 String 생성자 요약 합니다.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Security

SecurityCriticalAttribute
직접 실행 호출자에 대 한 완전 신뢰가 필요 합니다. requires full trust for the immediate caller. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다. This member cannot be used by partially trusted or transparent code.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

지정한 횟수만큼 반복되는 지정된 유니코드 문자가 나타내는 값으로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

public:
 String(char c, int count);
public String (char c, int count);
new string : char * int -> string
Public Sub New (c As Char, count As Integer)

매개 변수

c
Char Char Char Char

유니코드 문자입니다. A Unicode character.

count
Int32 Int32 Int32 Int32

c가 발생하는 횟수입니다. The number of times c occurs.

Exceptions

Remarks

참고

이 및 기타에 대 한 포괄적인 사용 정보와 예제 String 생성자 오버 로드를 참조 합니다 String 생성자 요약 합니다.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

중요

This API is not CLS-compliant.

유니코드 문자 배열에 대한 지정된 포인터가 나타내는 값, 해당 배열 내의 시작 문자 위치 및 길이로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

public:
 String(char* value, int startIndex, int length);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (char* value, int startIndex, int length);
new string : nativeptr<char> * int * int -> string

매개 변수

value
Char*

유니코드 문자 배열에 대한 포인터입니다. A pointer to an array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

내의 시작 위치입니다. The starting position within value.

length
Int32 Int32 Int32 Int32

value 내에서 사용할 문자의 수입니다. The number of characters within value to use.

Exceptions

startIndex 또는 length가 0보다 작거나 value + startIndex로 인해 포인터 오버플로가 발생하거나, 현재 프로세스에서 주소가 지정된 모든 문자에 대한 읽기 액세스 권한을 갖지는 않습니다. startIndex or length is less than zero, value + startIndex cause a pointer overflow, or the current process does not have read access to all the addressed characters.

value는 잘못된 유니코드 문자가 포함된 배열을 지정하거나 value + startIndex가 64000보다 작은 주소를 지정합니다. value specifies an array that contains an invalid Unicode character, or value + startIndex specifies an address less than 64000.

Remarks

참고

이 및 기타에 대 한 포괄적인 사용 정보와 예제 String 생성자 오버 로드를 참조 합니다 String 생성자 요약 합니다.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Security

SecurityCriticalAttribute
직접 실행 호출자에 대 한 완전 신뢰가 필요 합니다. requires full trust for the immediate caller. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다. This member cannot be used by partially trusted or transparent code.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

유니코드 문자 배열에서 나타내는 값, 해당 배열 내의 시작 문자 위치 및 길이로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

public:
 String(cli::array <char> ^ value, int startIndex, int length);
public String (char[] value, int startIndex, int length);
new string : char[] * int * int -> string
Public Sub New (value As Char(), startIndex As Integer, length As Integer)

매개 변수

value
Char[]

유니코드 문자 배열입니다. An array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

내의 시작 위치입니다. The starting position within value.

length
Int32 Int32 Int32 Int32

value 내에서 사용할 문자의 수입니다. The number of characters within value to use.

Exceptions

startIndex 또는 length가 0보다 작습니다. startIndex or length is less than zero. 또는 -or- startIndexlength의 합계가 value의 요소 수보다 큽니다. The sum of startIndex and length is greater than the number of elements in value.

Remarks

참고

이 및 기타에 대 한 포괄적인 사용 정보와 예제 String 생성자 오버 로드를 참조 합니다 String 생성자 요약 합니다.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

중요

This API is not CLS-compliant.

8비트 부호 있는 정수 배열에 대한 지정된 포인터가 나타내는 값, 해당 배열 내의 시작 위치 및 길이로 String 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

public:
 String(System::SByte* value, int startIndex, int length);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value, int startIndex, int length);
new string : nativeptr<sbyte> * int * int -> string

매개 변수

value
SByte*

8비트 부호 있는 정수에 대한 포인터입니다. A pointer to an array of 8-bit signed integers. 정수는 현재 시스템 코드 페이지 인코딩(즉, Default로 지정된 인코딩)을 사용하여 해석됩니다. The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

startIndex
Int32 Int32 Int32 Int32

내의 시작 위치입니다. The starting position within value.

length
Int32 Int32 Int32 Int32

value 내에서 사용할 문자의 수입니다. The number of characters within value to use.

Exceptions

startIndex 또는 length가 0보다 작습니다. startIndex or length is less than zero. 또는 -or- value + startIndex로 지정된 주소가 현재 플랫폼에 비해 너무 큽니다. 즉, 주소 계산이 오버플로됩니다. The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed. 또는 -or- 초기화할 새 문자열의 길이가 너무 커서 할당할 수 없습니다. The length of the new string to initialize is too large to allocate.

value + startIndex로 지정된 주소가 64K 미만입니다. The address specified by value + startIndex is less than 64K. 또는 -or- value가 ANSI로 인코딩되었다고 가정하고 String의 새 인스턴스를 value를 사용하여 초기화할 수 없습니다. A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

value, startIndexlength가 전체적으로 잘못된 주소를 지정합니다. value, startIndex, and length collectively specify an invalid address.

Remarks

참고

이 및 기타에 대 한 포괄적인 사용 정보와 예제 String 생성자 오버 로드를 참조 합니다 String 생성자 요약 합니다.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Security

SecurityCriticalAttribute
직접 실행 호출자에 대 한 완전 신뢰가 필요 합니다. requires full trust for the immediate caller. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다. This member cannot be used by partially trusted or transparent code.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

중요

This API is not CLS-compliant.

8비트 부호 있는 정수 배열에 대한 지정된 포인터가 나타내는 값, 해당 배열 내의 시작 문자 위치, 길이 및 String 개체로 Encoding 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

public:
 String(System::SByte* value, int startIndex, int length, System::Text::Encoding ^ enc);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value, int startIndex, int length, System.Text.Encoding enc);
new string : nativeptr<sbyte> * int * int * System.Text.Encoding -> string

매개 변수

value
SByte*

8비트 부호 있는 정수에 대한 포인터입니다. A pointer to an array of 8-bit signed integers.

startIndex
Int32 Int32 Int32 Int32

내의 시작 위치입니다. The starting position within value.

length
Int32 Int32 Int32 Int32

value 내에서 사용할 문자의 수입니다. The number of characters within value to use.

enc
Encoding Encoding Encoding Encoding

value에서 참조하는 배열이 인코딩되는 방법을 지정하는 개체입니다. An object that specifies how the array referenced by value is encoded. encnull이면 ANSI 인코딩으로 간주됩니다. If enc is null, ANSI encoding is assumed.

Exceptions

startIndex 또는 length가 0보다 작습니다. startIndex or length is less than zero. 또는 -or- value + startIndex로 지정된 주소가 현재 플랫폼에 비해 너무 큽니다. 즉, 주소 계산이 오버플로됩니다. The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed. 또는 -or- 초기화할 새 문자열의 길이가 너무 커서 할당할 수 없습니다. The length of the new string to initialize is too large to allocate.

value + startIndex로 지정된 주소가 64K 미만입니다. The address specified by value + startIndex is less than 64K. 또는 -or- valueenc로 지정된 대로 인코딩되었다고 가정하고 String의 새 인스턴스를 value를 사용하여 초기화할 수 없습니다. A new instance of String could not be initialized using value, assuming value is encoded as specified by enc.

value, startIndexlength가 전체적으로 잘못된 주소를 지정합니다. value, startIndex, and length collectively specify an invalid address.

Remarks

참고

이 및 기타에 대 한 포괄적인 사용 정보와 예제 String 생성자 오버 로드를 참조 합니다 String 생성자 요약 합니다.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Security

SecurityCriticalAttribute
직접 실행 호출자에 대 한 완전 신뢰가 필요 합니다. requires full trust for the immediate caller. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다. This member cannot be used by partially trusted or transparent code.

Applies to