Console.Clear(); 로 콘솔창을 청소할 수 있다.
int a, b;
float c = 0;
try
{
Console.Write("첫번째 정수를 입력하세요 : ");
a = int.Parse(Console.ReadLine());
Console.Write("두번째 정수를 입력하세요 : ");
b = int.Parse(Console.ReadLine());
c = a / b;
}
catch (FormatException eObj)
{
Console.WriteLine(eObj);
Console.WriteLine("숫자가 아닌 문자를 입력했습니다");
Environment.Exit(0);
}
catch(DivideByZeroException eObj)
{
Console.WriteLine(eObj);
Console.WriteLine("0으로 나누려했습니다.");
Environment.Exit(0);
}
catch (Exception eObj)
{
Console.WriteLine(eObj);
Console.WriteLine("변수의 값이 올바르지 않습니다.");
Environment.Exit(0);
}
finally
{
Console.WriteLine("\n프로그램이 실행 되었습니다.");
}
Console.WriteLine("A/B값은 {0} 입니다.", c);
return 0;int.Parse는 string 문자열을 받는다. "11"을 넣으면 1의 아스키코드 두개가 되는것.
구문에서는 Console.ReadLine();을 사용했는데, 이건 콘솔창에서 입력한 값을 읽으라는 의미.
a같은 문자를 넣으면 뭔가 이상한게뜨는데 이건 예외처리로 에러를 못잡아서 그런것임.
catch(Exception)에서 Exception은 예외라는 뜻으로 프로그램을 실행하다가 실행 중 오류(런타임 에러)가 발생하면 예외로 처리한다.
Environment.Exit(0) : Environment라는 클래스안에 Exit라는 메서드를 호출
Exit가 호출되면 얘가있는 위치에서 프로그램이 종료된다. 거대한 프로그램을 만들었는데 Exit를 넣어버리면 사용하고있는 모든 시스템이 종료되기때문에 시말서를 쓰게되니 최대한 사용을 자제하자.
Exit(0)에서 0은 정상종료를 뜻하며, 0이 아닌 숫자는 비정상종료를 뜻함.
비정상 종료는 사용자가 정의할 수 있음.
(예를들어, 1은 입력이 잘못됬을때, 2는 마우스 입력이 잘못했을때 등등)
100대는 출력이 에러
200대는 입력받을때 에러
300대는 네트웤이 에러났을때.. 등등
return (숫자); 를 입력하는데 어떤 숫자를 쓰는 것에대해 이유가 있는게 좋음.(위에서 쓰는것처럼)
사실은 귀찮아서 잘 사용안함.
finally
에러가뜨면 finally는 실행되지 않는다.
제대로된 값을 입력할때까지 무한반복하는 프로그램(Clear를썼기때문에 오류 메세지는 뜨지않는다.)
int a, b;
float c = 0;
while (true) {
try
{
Console.Write("첫번째 정수를 입력하세요 : ");
a = int.Parse(Console.ReadLine());
Console.Write("두번째 정수를 입력하세요 : ");
b = int.Parse(Console.ReadLine());
c = a / b;
}
catch (FormatException eObj)
{
Console.WriteLine(eObj);
Console.WriteLine("숫자가 아닌 문자를 입력했습니다");
continue;
}
catch(DivideByZeroException eObj)
{
Console.WriteLine(eObj);
Console.WriteLine("0으로 나누려했습니다.");
continue;
}
catch (Exception eObj)
{
Console.WriteLine(eObj);
Console.WriteLine("변수의 값이 올바르지 않습니다.");
continue;
}
finally
{
Console.WriteLine("\n프로그램이 실행 되었습니다.");
Console.Clear();
}
Console.WriteLine("A/B값은 {0} 입니다.", c);
break;
}참고로 Exception을할때 범위가 좁은거부터 배치해야한다. 만약에 Exception을 맨위에 배치하면 모든 예외를 Exception으로 잡고, 범위가 좁은 예외는 아예 처리되지않기때문에 컴파일 오류가 난다.
메서드
public class A
{
public static void MethodA()
{
System.Console.WriteLine("MethodA() in class A");
}
}
public class B
{
static void Main(string[] args)
{
A.MethodA();
}
}
객체이름.메서드이름() 일때,
객체이름이라는 소속을 써줘야한다. 근데 객체 생성을 안했을때가 있는데 이때 static을쓰면 클래스 이름을 써서 메서드이름을 사용할 수 있다.
예를들어 구문을 Console.WriLine으로쓰는데 Console이라는 객체를 만들지않았는데 사용할 수 있는 것이 대표적임
MethodA()를 다른 클래스에서 호출하고싶을때, MethodA()메서드 왼쪽에 static을 붙이면 객체를 생성하지않아도 메서드를 호출할 수 있다.(정적 메서드로 만든다)
메인 메서드에도 static이 붙여져있는데 가장 먼저 실행하는게 Main인데 클래스 B에서 객체 B를 만들으라는 명령을 하지않았기때문에 호출할 수가없는데, 이때 static을 붙여서 호출할 수 있다.
이것때문에 모든 엔트리 포인트(메인메서드)에서는 거의다 static이 붙여져있다.
메서드 안에서 메서드를 호출하는 예제
public static void MethodA()
{
System.Console.WriteLine("메서드 A입니다.");
}
public static void MethodB()
{
MethodA();
System.Console.WriteLine("메서드 B입니다.");
MethodA();
}
static void Main(string[] args)
{
MethodB();
Console.WriteLine();
MethodA();
}
public static ulong Factorial(ulong number)
{
if (number <= 1) return 1;
else
return number * Factorial(number - 1);
}
public static void Main(string[] args)
{
ulong nfact = Factorial(5);
Console.WriteLine("5*4*3*2*1 = " + nfact);
}
위의 코드는 잘못하면 무한반복이되지만 코드가 굉장히 짧아보이는 효과가 있다.(사실 for문으로 가능하긴하다)
아니면 탈출하는 경로인 if문을 이용해서 탈출하는 구문을 생각해볼수도 있다.
할당되지 않은 지역 변수를 사용했습니다.
메서드안에 만들어진 변수를 지역 변수라고한다.
지역 변수는 만들어져있는데 값을 넣지 않으면 메모리는 차지하는데 값은 쓰레기값으로 되어있다.
내가 땅을사면 그 땅에는 흙이있든 뭐든 있기때문에 건물을 지으려면 그것들을 치우고 해야한다.
메모리에도 어떤 값을 가지고있기때문에 그 값을 다른 값으로 대입시켜줘야한다.
따라서 할당되지 않은 지역 변수를 사용했습니다.라는 컴파일 오류가뜨면 unInitVar에 다른 값을 대입해서 초기화해줘야 한다.
변수에 static이 붙어있지않은거랑 static이 붙어있는것의 차이점
Main에서 e1을 만들었는데 이건 지역변수로써 쓰레기값이 들어가있다.(그래서 바로 e1. 을써주면 컴파일에러가난다.)
e2도 마찬가지로 지역변수로써 쓰레기값이 들어있다.
new Example();로 Example이라는 객체를 생성 -> e1에 example을 넣어줌
classvari2라는 클래스 변수(0이 들어가있는)가 만들어지는데, classvari2에 0이 Example()의 메서드에서 ++이 된다.
classvari1은 객체를 생성하지않아도 이미 생성되어있다. (이미 생성되있지만 클래스 소속이다. 참고로 classvari2는 객체 소속이다)
객체 소속은 객체가 있어야만 존재할 수 있다.
클래스 소속은 클래스이름만 있어도 존재할 수 있다.
그럼 편하게 클래스 소속만 다 만들면 되지않느냐?
1. 일단 클래스 소속들은 생성을하든말든 메모리에 계속 점유하기때문에 여러개를 만들면 메모리가 버티지 못할 수도 있다. 메모리가 버티지못하면 프로그램이 터져버리기 때문에 이런 변수는 최소한으로만 만들어야한다.
2. 이미 컴파일할때 만들어져있기 때문에 여러개를 만들면 실행하는 파일이 많이 커진다.
public class Example
{
public static int classvari1;
public int classvari2;
public Example()
{
classvari1++;
classvari2++;
}
public void Print()
{
Console.WriteLine("classvari1 : " + classvari1);
Console.WriteLine("classvari2 : " + classvari2);
Console.WriteLine();
}
public static void Main(string[] args)
{
Example e1;
Example e2;
e1 = new Example();
e1.Print();
e2 = new Example();
e2.Print();
e1.Print();
}
}
위의 코드에서 classvari1과 classvari2는 지역변수가 아니라서 초기화를 안해줘도 컴파일 오류가 뜨지않는다.
Example 클래스 소속이기때문에 지역변수가아니라 클래스 변수라고한다.
우리가 값을 안넣어주면 기본적으로 0을 넣어준다.(정확히는 메모리 공간에 비트가 모두 0으로 채워넣어져있다)
땅을 샀는데 밭을 전부 갈아논걸 사게되어서 깨끗이 청소되있는 밭이여서 농사짓기에는 문제가 없다.
하나만 만들어지고 하나가 존재하고있다.
디버깅모드중에
F10은 결과만 보겠다는 키
F11은 그 과정을 다 보겠다는 키
변수에는
지역변수({ }까지), 클래스변수(클래스는 영원하다. 프로그램이 죽을때까지), 인스턴스 변수(인스턴스가 살아있을때까지)가 있음.
namespace Param1
{
using System;
public class ParamValue
{
public void Increase(int n)
{
n++;
}
public static void Main(string[] args)
{
int i = 10;
ParamValue pv = new ParamValue();
Console.WriteLine("호출 전 : {0}", i);
pv.Increase(i);
Console.WriteLine("호출 후 : {0}", i);
// 메서드 간의 지역변수는 분리된다.
// 호출 전 후와 값은 같다.
}
}
}
메서드 간의 지역변수는 분리되기때문에 메인 메서드에서 int i = 10;을 선언하고 pv라는 객체를 생성해준다. 이때 WriteLine으로 호출 전의 i값 10을 출력하고, Increase로 i를 호출해서 n이되어서 10++이 되어서 11이 되더라도 Increase의 n의 값이 11이 된것이지 메인 메서드에서 i의 값이 변한게 아니기때문에 WriteLine으로 호출 후의 i값은 그대로 10이 된다.
namespace Param2
{
using System;
public class ParamRef
{
public int myVal = 10;
}
public class ParamTest
{
public static void Increase(ParamRef varRef)
{
varRef.myVal++; //increase이 ParmRef를 가리키며 myVal에 +1이 됨
}
public static void Main(string[] args)
{
ParamRef pr = new ParamRef();
Console.WriteLine("호출 전 : {0}", pr.myVal);
ParamTest.Increase(pr);
Console.WriteLine("호출 후 : {0}", pr.myVal);
}
}
}
Heap 영역에 ParmRef 객체 생성
stack 영역에 메인메서드에서 객체참조변수이자 지역변수인 타입이 ParamRef인 pr을 생성
stack 영역에 Increase메서드에서 varRef
ParamRef pr = new ParamRef();
pr을 ParamRef에 대입
ParamRef 안에 myVal는 10이 들어가있다.
WriteLine에서 pr.myVal은 pr의 myVal을 찾아라라는 의미로 10이 출력된다.
ParamTest.Increase는 static이라서 호출이 가능하고, pr
(Param은 같이 속해있기때문에 생략이 가능하다)
객체의 주소(레퍼런스)를 가지고있다. 레퍼런스는 Increase나 pr이 같으므로 Heap영역의 ParmRef를 가리키고있다.
1. 값 변수
2. 참조형 변수 두개를 묶어서 값 전달
3. 값
4. 참조형 변수 두개를 묶어서 참조 전달
namespace Param3
{
using System;
public class ParamValue
{
public void Increase(ref int n)
{
n++;
}
public static void Main(string[] args)
{
int i = 10;
ParamValue pv = new ParamValue();
Console.WriteLine("호출 전 : {0}", i);
pv.Increase(ref i);
Console.WriteLine("호출 후 : {0}", i);
}
}
}
Main메서드에서
i에 10을 대입
pv라는 객체 생성
코드에 i앞에 ref를 적어줬는데, 이때 Increase를 들여다보는데, 이때 n을 새로 생성되는데 i와 n을 동일시하겠다는 뜻이다.(같은 사람을 다른 호칭으로 보내는 것처럼 일종의 별칭이라고 생각하면 된다)
n을 ++해줬는데 이때 i가 ++이 되어서 다시 메인 메서드로 돌아와서 호출하면 11이된다.
원래 Main메서드와 Increase는 각각 분리가되는데 ref를 적어줌으로써 Main의 정보를줘서 접근할 수 있게 된다. Param1 예제는 int n을 Main메서드랑 Increase 둘다 만들어줘서 메모리를 두배로 쓰게되는데, ref를 사용하면 Main에서 int i만 선언하게되어서 메모리의 사용을 최소화할 수도 있다.
ref만 쓰면된다?
서로의 용도가 따로 있다. Main의 값을 다르게하고싶으면 쓰게되고, 변하지않게하면서 변수와 값을 쓰고싶으면 쓰지않는 용도로 쓰이게 된다.
참고로 참조형 변수는 Heap영역에있는 친구들이라서 주소를 사용하는 것임
namespace Param4
{
using System;
public class ParamRef
{
public int myVal = 10;
}
public class ParamTest
{
public static void Increase(ref ParamRef varRef)
{
varRef.myVal++;
}
public static void Main(string[] args)
{
ParamRef pr = new ParamRef(); //
Console.WriteLine("호출 전 : {0}", pr.myVal);
ParamTest.Increase(ref pr);
Console.WriteLine("호출 후 : {0}", pr.myVal);
}
}
}
ParamRef pr = new ParamRef();==========================
new heap영역에 paramRef생성 (이떄 myVal에는 10이 들어가있다)
Main 메서드에서 stack영역에 pr 객체 참조변수 생성
=을 통해서 보통 1000번지의 주소를 pr에 전달
항상 주소를 넣기때문에 객체참조변수의 크기는 항상 같다.
Console.WriteLine("호출전 : {0}", pr.myVal);==================================
myVal을 호출해서 10을 출력
ParamTest.Increase(ref pr);==================================
pr의 정보를 Increase 메서드에 객체를 만들지 않고 pr과 varRef를 같게 본다.
이때 varRef를 ++해주는데 pr과 같으므로 pr을 ++해준다. -> 10이 11이 된다.
Increase 메서드 영역과 varRef가 사라진다.
Console.WriteLine("호출후 : {0}", pr.myVal);==========================
myVal이 11이 되었으므로 출력하면 11이 출력된다.
namespace Param5
{
using System;
public class ParamValue
{
public void Increase(out int n)
{
n = 11;
}
static void Main(string[] args)
{
int i = 6;
ParamValue pv = new ParamValue();
pv.Increase(out i);
Console.WriteLine("호출 후 값 : {0}", i);
Console.WriteLine("i의 값 : {0}", i);
// 출력인자 방식
}
}
}
out을 쓰게되면 ref효과가난다. 일종의 출력용의 ref로 사용하는 편이다. 여러개를 return받고싶을때 사용할 수도있다.
int Test(out int T)
{
T = 6;
return 3;
}
라는 메서드를 정의해놓으면
Main구문에서
int A = Test(B); 로 메서드를 호출하면
B에는 3이 반환되고
A에는 6이 반환된다.
위의 예제는 int형만 받았는데 이번에는 다양한 타입을 받아보자
namespace Param6_1
{
using System;
public class ParamValue
{
public static void VarMethod(params object[] arr)
{
Console.WriteLine("[가변 인자 개수] : " + arr.Length + "개");
Console.Write("[인자 전체] : ");
foreach(object one in arr) // object는 최상위라서 아무타입이나 다 받는다.
{
Console.Write(one.ToString() + " ");
}
Console.WriteLine();
Console.Write("[문자열 타입] : ");
for(int i = 0; i<arr.Length; ++i)
{
Type t = arr[i].GetType();
if (t.Equals(typeof(System.String)))
{
Console.Write(arr[i] + " ");
}
}
Console.WriteLine();
Console.Write("[정수 타입] : ");
foreach(object one in arr)
{
Type t = one.GetType();
if (t.Equals(typeof(System.Int32)))
{
Console.Write(one + " "); // .Tostring()이 생략되어있다.
}
}
Console.WriteLine();
Console.Write("[Float 타입] : ");
foreach (object one in arr)
{
Type t = one.GetType();
if (t.Equals(typeof(System.Single)))
{
Console.Write(one + " ");
}
}
Console.WriteLine();
Console.Write("[실수 타입] : ");
foreach (object one in arr)
{
Type t = one.GetType();
if (t.Equals(typeof(System.Double)))
{
Console.Write(one + " ");
}
}
Console.WriteLine();
}
static void Main(string[] args)
{
VarMethod(1000, 2000, "3000", "헬로", 3.1, 3.2f);
// 3.1은 더블형, 3.2f는 float형
}
}
}
arr배열에 1000, 2000, "3000", "헬로", 3.1, 3.2f 가 존재한다.
[0] [1] [2] [3] [4] [5]
GetType은 현재 인스턴스의 Type을 가져온다.
if문에서 각각의 타입들을 비교해서 일치한다면 Console.Write로 해당되는 데이터값이 출력된다.
Equals는 bool형으로써 현재 시스템 형식이 ()안에 넣어줬던 type과 같으면 True, 그렇지 않으면 false가 출력된다.
따라서 문자열 타입 구문에서 "3000"이 System.String에 해당되기때문에 Console.WriteLine으로 출력된다.
(참고로 typeof는 예약어이다)
C# Params 규칙
1. params 키워드는 타입 왼쪽에 기입
2. 반드시 1차원 배열로 선언
namespace _20200701_002
{
class Program
{
// 메서드 이름이 같더라도 매개변수, 즉 인자값으로 구별할 수 있다. -> 이것을 메서드 오버로딩이라고 부른다.
// 객체지향 용어이다.
static double Add(Double iNum1, Double iNum2)
{
Double iNum3 = iNum1 + iNum2;
return iNum3;
}
static float Add(float iNum1, float iNum2)
{
float iNum3 = iNum1 + iNum2;
return iNum3;
}
static int Add(int iNum1, int iNum2)
{
int iNum3 = iNum1 + iNum2;
return iNum3;
}
//static double AddDouble(Double iNum1, Double iNum2)
//{
// Double iNum3 = iNum1 + iNum2;
// return iNum3;
//}
//static float AddFloat(float iNum1, float iNum2)
//{
// float iNum3 = iNum1 + iNum2;
// return iNum3;
//}
//static int AddInt(int iNum1, int iNum2)
//{
// int iNum3 = iNum1 + iNum2;
// return iNum3;
//}
static void Main(string[] args)
{
int Num1 = 3;
int Num2 = 4;
int Num3 = Num1 + Num2;
Console.WriteLine("{0} = {1} + {2}", Num3, Num1, Num2);
int iNum4 = Add(5, 6);
Console.WriteLine("{0} = {1} + {2}", iNum4, 5, 6);
float fNum5 = Add(5.1f, 6.1f);
Console.WriteLine("{0} = {1} + {2}", fNum5, 5.1f, 6.1f);
double dNum6 = Add(5.1, 6.1);
Console.WriteLine("{0} = {1} + {2}", dNum6, 5.1, 6.1);
//int iNum7 = Add(5, 6); // 이 코드는 사용자가 선택하지않았지만, 컴파일러가 자동으로 인자를 선택해서 출력해준다.
//오버로딩의 조건은 인자의 타입이지 반환타입은 전혀 상관이없다.
// 메서드의 이름이 같고 인자가 다르게 만드는 것을 메서드 오버로딩이라고한다.
//int iNum4 = AddInt(5, 6);
//Console.WriteLine("{0} = {1} + {2}", iNum4, 5, 6);
//float fNum5 = AddFloat(5.1f, 6.1f);
//Console.WriteLine("{0} = {1} + {2}", fNum5, 5.1f, 6.1f);
//double dNum6 = AddDouble(5.1, 6.1);
//Console.WriteLine("{0} = {1} + {2}", dNum6, 5.1, 6.1);
//
}
}
}
메소드 오버로딩
1. 메소드의 이름이 동일할 것
2. 메소드의 매개변수가 서로 다를 것(갯수, 순서 등)
배열 객체 참조변수 -> 객체 참조 변수 (Stack)
배열 객체 - > 객체 (Heap) , new를 통해 생성
namespace _20200701_002_001
{
class ArrayClass
{
static void Main(string[] args)
{
System.Console.Write("행의 개수를 입력하세요. : ");
string s1 = System.Console.ReadLine();
System.Console.Write("열의 개수를 입력하세요. : ");
string s2 = System.Console.ReadLine();
int rows = int.Parse(s1);
int cols = int.Parse(s2);
int[,] myArray = new int[rows, cols]; // 2차원 배열 생성
System.Console.WriteLine(rows + "*" + cols + "배열이 생성되었습니다.");
}
}
}
[ ]만 써주면 1차원, [ , ]를 쓰면 2차원, [ , , ]를쓰면 3차원
int [3, 4] 일때 3을 행, 4를 렬로 구별한다.
int[,] myArray = new int[rows, cols]; =================
(Left) int형의 myArray라는 2차원의 배열을 스택 영역에 생성
(Right) int형의 2차원 배열을 힙영역에 생성
using System;
class CopyArray
{
static void Main(string[] args)
{
long[] Original = new long[4] { 3, 1, 2, 0 };
long[] Copy = Original;
Console.WriteLine("1 : " + Copy[3]);
Original[3] = Original[1] + Original[2];
long CopyValue = Copy[3];
Console.WriteLine("2 : " + Copy[3]);
}
}
long[] Original = new long[4] { 3, 1, 2, 0 }; ====================
스택에 original 생성, 힙영역에 3,1,2,0 의 객체생성 (참고로 3,1,2,0은 순서대로 [0], [1], [2], [3] 이다.)
=을 통해 original 이 힙영역의 3,1,2,0의 객체를 향한다.
long[] Copy = Original; =======================
스택에 Copy 생성후 Original을 대입하는데 이것은 힙 영역의 객체를 향한다.
이때 오리지날과 카피는 같은 곳을 향하고있다.
Console.WriteLine("1 : " + Copy[3]); ==================
Copy[3]의 위치는 3, 1, 2, 0 중에 [3] 위치인 0을 뜻하므로 0을 출력한다.
Original[3] = Original[1] + Original[2]; ==================
Original[3]의 자리에 [1] + [2]의 값, 즉 1 + 2를 대입해준다.
long CopyValue = Copy[3];=====================
스택영역에 CopyValue를 생성하고 Copy[3]을 대입해준다. 즉 힙영역의 [3]의 위치의 값을 향한다.
Console.WriteLine("2 : " + Copy[3]);=====================
Copy[3]의 위치에있는 값을 출력하는데 위에서 1+2의 값인 3이 출력된다.
using System;
class ArrayRank
{
static void Main(string[] args)
{
int[] Array1 = new int[4];
int[,] Array2 = new int[2, 3];
int[,,] Array3 = new int[2, 4, 3];
Console.WriteLine("Array1의 차원 : " + Array1.Rank);
Console.WriteLine("Array2의 차원 : " + Array2.Rank);
Console.WriteLine("Array3의 차원 : " + Array3.Rank);
}
}
using System;
class ArraySort
{
static void Main(string[] args)
{
int i = 0;
//배열선언
int[] SortArray = new int[5] { 15, 32, 11, 20, 43 };
Console.Write("현재배열 출력 : ");
for(i = 0; i<SortArray.Length; i++)
{
Console.Write(SortArray[i] + " ");
}
Console.WriteLine();
//sort메서드로 배열정렬
System.Array.Sort(SortArray);
// 정렬하는 메서드가 C#에 있는데 걔가 배열을 정렬시켜준다.
Console.Write("정렬된 배열 출력 : ");
for (i = 0; i < SortArray.Length; i++)
{
Console.Write(SortArray[i] + " ");
}
Console.WriteLine();
}
}
using System;
class ArrayClear1
{
static void Main(string[] args)
{
int[] ClearArray = { 5, 4, 2, 6, 7, 1 };
Console.WriteLine("***********클리어 전*************");
foreach(int iNum in ClearArray)
{
Console.WriteLine(iNum);
}
System.Array.Clear(ClearArray, 0, ClearArray.Length);
Console.WriteLine("*************클리어 후****************");
foreach(int iNum in ClearArray)
{
Console.WriteLine(iNum);
}
}
}
using System;
class ArrayClaer2
{
static void Main(string[] args)
{
int i = 0;
int[] ClearArray = { 5, 4, 2, 6, 7, 1 };
System.Array.Clear(ClearArray, 1, 2);
// [1]부터 두개를 지운다.
for(i=0; i<ClearArray.Length; i++)
{
Console.WriteLine(ClearArray[i]);
}
}
}
using System;
class ArrayClone
{
static void Main(string[] args)
{
int i = 0;
int[] Original = { 5, 4, 2, 6, 7, 1 };
int[] Clone = (int[])Original.Clone();
for (i = 0; i<Clone.Length; i++)
{
Console.Write(Clone[i] + " ");
}
Console.WriteLine();
Original[3] = 20;
Console.WriteLine("복제계열[3] : " + Clone[3]);
}
}
using System;
class Program
{
static void Main(string[] args)
{
int i = 0;
int[] Original = { 5, 4, 2, 6, 7, 1 };
int[] Clone = (int[])Original.Clone();
Console.Write("Original : ");
foreach (int one in Original)
Console.Write(one + " ");
Console.WriteLine();
Console.Write("Clone : ");
foreach (int one in Clone)
Console.Write(one + " ");
Console.WriteLine();
Console.WriteLine("***************************");
System.Array.Sort(Clone);
Console.Write("Original : ");
foreach (int one in Original)
Console.Write(one + " ");
Console.WriteLine();
Console.Write("Clone : ");
foreach (int one in Clone)
Console.Write(one + " ");
Console.WriteLine();
}
}
'개발자과정준비 > C#' 카테고리의 다른 글
| C# 복습 (4) (0) | 2020.07.20 |
|---|---|
| C# 복습 (3) (0) | 2020.07.14 |
| C# 복습 (1) (0) | 2020.07.14 |
| [C#] 11. C# 초급(5) 클래스 형변환, 중첩클래스, 추상클래스, 델리게이트 (0) | 2020.06.07 |
| [C#] 10. C# 초급 (4) 다형성, 오버라이드, 오버로드 (0) | 2020.06.04 |
