C언어 연산자 - OR연산일때 앞에 1이 되서 성립되면 뒤는 실행하지 않음
int x=3, y=4, z=2;
while(x-- > 0) {
if(y++ < 5 || --z > 1 && x > 1)
z += x;
else
y += z;
}
printf("%d, %d, %d\n", x,y,z);//1회차
/*
첫 while문 조건
3-- > 0
x=2
if문 y=4++<5 true OR연산일때 앞에 1이 되서 성립되면 뒤는 실행하지 않음
y=5
z+=x; 2+2=4 z=4
x=2 y=5 z=4 -
*///2회차
/*
while문
x-- > 0
x=1
if문
5++ < 5 false
y=6
--z > 1 && x > 1
z=3 > 1 && 1 > 1 = 1 && 0 -> 0
y += z;
x=1 y=9 z=3
*///3회차
/*
while문
x-- > 0
x=0
if문
9++ < 5 false
y=10
--z > 1 && x > 1
z=2 > 1 && 0 > 1 = 1 && 0 -> 0
y += z;
x=0 y=12 z=2
*/
//4회차
/*
x-- > 0 x가 0이기에 while 조건이 성립하지 않아서 종료
x=-1
*/-1, 12, 2
c언어 재귀 함수 - return
int mystFunc(int x, int y) {
if(x<2){
x = y-x;
return x;
} else {
int nX = x-2;
int nY = y-x;
int ret = mystFunc(nX,nY);
printf("%d, %d, %d, %d\n", x,y,nX,nY);
return ret + x;
}
}
int main() {
int result = mystFunc(5, 14);
printf("%d\n", result);
return 0;
}x=5 y=14
nX=3
nY=9
ret = mystFunc(3, 9);
x=3 y=9 nX=1 nY=6
ret = mystFunc(1, 6)
x=y-x -> x=6-1
return x -> return 5
ret=5
x=3 y=9 nX=1 nY=6 ret=5
printf("%d, %d, %d, %d\n", x,y,nX,nY); //3, 9, 1, 6 출력
return ret + x; //5+3=8
x=5 y=14 nX=3 nY=9 ret=8
printf("%d, %d, %d, %d\n", x,y,nX,nY); //5, 14, 3, 9 출력
return ret + x; //8+5=13
result=13
printf("%d\n", result); //13 출력3, 9, 1, 6
5, 14, 3, 9
13
JAVA 오버라이딩
class A{
int num = 50;
public A(){
System.out.print("X");
}
public A(int n) {
System.out.print("Y");
}
public voide printNum(){
System.out.print(num);
}
}
class B extends A{
int num = 100;
public B() {
System.out.print("A");
}
public B(int n) {
super(n);
System.out.print("B");
}
public void printNum()
System.out.print(n);
}
}
class C extends B{
int num = 200;
public C() {
System.out.print("C");
}
public C(int n) {
super(n);
System.out.print("D");
}
public void printNum() {
System.out.print(num);
}
public void show() {
System.out.pritnt("E");
}
public static void main(String[]{
A a1 = new C();
B b1 = new C(5);
A a2 = new B();
a1.printNum();
b1.printNum();
a2.printNum();
}
} A a1 = new C(); //부모를 받음
B b1 = new C(5);
A a2 = new B();
1. A a1 = new C();
//생성자 C의 부모 B로 갔다 B의 부모 A로 가고 먼저 변수를 미리 저장함
//A.num = 50 저장
System.out.print("X"); // X 출력
//A가 끝나면 B로 가서 먼저 B의 변수를 미리 저장
//B.num = 100 저장
System.out.print("A"); //A 출력
//B가 끝나면 C로 가서 먼저 C의 변수를 미리 저장
//C.num = 200 저장
System.out.print("C"); //C 출력
2. B b1 = new C(5);
//생성자 c에 인자를 보고 간다
public C(int n) {
super(n);
System.out.print("D");
}
//super가 있기에 인자를 가지고 가고 없다면 그냥 인자가 없는 public B()로 간다.
//부모 B로 가서 super가 있기에 부모 A에 간다.
//먼저 A의 변수를 미리 저장
//A.num = 50 저장
System.out.print("Y"); //Y 출력
//A가 끝나면 B로가서 B의 변수를 미리 저장
//B.num = 100 저장
System.out.print("B"); //B 출력
//B가 끝나면 C로 가서 C의 변수를 미리 저장
//C.num = 200 저장
System.out.print("D"); //D 출력
3. A a2 = new B();
//생성자 B의 부모 A로 가서 미리 A의 변수를 저장
//A.num = 50
System.out.print("X"); //X 출력
//A가 끝나면 B로 가서 먼저 B의 변수를 미리 저장
//B.num = 100 저장
System.out.print("A"); //A 출력
4. a1.printNum(); //생성자 최종으로 오버라이딩한 printNum
public void printNum() { //C의 printNum
System.out.print(num);
}
//C의 num 200 출력 - 만약 num이 없다면 부모의 num 부모의 num도 없다면 그 부모의 num을 사용
5. b1.printNum(); //생성자 최종으로 오버라이딩한 printNum
//C의 num 200 출력
6.a2.printNum(); //생성자 기준으로 최종으로 오버라이딩한 printNum
//B의 NUM 100출력XACYBDXA200200100
class Animal {
String type = "동물"; // Animal 클래스의 type 변수
public void eat() {
System.out.println(type + "이(가) 먹이를 먹습니다.");
}
}
class Dog extends Animal {
String type = "개"; // Dog 클래스의 type 변수 (Animal의 type을 숨김)
// eat 메서드는 오버라이딩하지 않았음
}
class Cat extends Animal {
String type = "고양이"; // Cat 클래스의 type 변수 (Animal의 type을 숨김)
@Override
public void eat() { // eat 메서드 오버라이딩
System.out.println(type + "이(가) 생선을 먹습니다.");
}
}
public class FieldHidingExample {
public static void main(String[] args) {
// Case 1: Animal 타입으로 선언하고 Dog 인스턴스 할당
Animal animalRef1 = new Dog();
System.out.println("animalRef1.type: " + animalRef1.type);
// 선언된 타입 Animal의 type에 접근
// Case 2: Dog 타입으로 선언하고 Dog 인스턴스 할당
Dog dogRef = new Dog();
System.out.println("dogRef.type: " + dogRef.type);
// 선언된 타입 Dog의 type에 접근
// Case 3: Animal 타입으로 선언하고 Cat 인스턴스 할당
Animal animalRef2 = new Cat();
System.out.println("animalRef2.type: " + animalRef2.type);
// 선언된 타입 Animal의 type에 접근
System.out.println("--- 메서드 호출 ---");
animalRef1.eat(); // 실제 인스턴스(Dog)에 오버라이딩된 eat이 없으므로 Animal의 eat 호출
animalRef2.eat(); // 실제 인스턴스(Cat)에 오버라이딩된 eat이 있으므로 Cat의 eat 호출
}
} //변수를 출력할 땐 앞에 타입을 보고 출력함
Animal animalRef1 = new Dog();
System.out.println("animalRef1.type: " + animalRef1.type);
//animalRef1.type - 선언된 Animal 타입의 type을 출력
Dog dogRef = new Dog();
System.out.println("dogRef.type: " + dogRef.type);
//dogRef.type - 선언된 dog 타입의 type을 출력
Animal animalRef2 = new Cat();
System.out.println("animalRef2.type: " + animalRef2.type);
//선언된 Animal 타입의 type 출력
//생성자 호출은 최종적으로 오버라이딩된 것을 출력
animalRef1.eat();
//dog에서 오버라이딩 되지 않았기에 부모의 eat 출력
animalRef2.eat();
//cat에서 최종적으로 오버라이딩 되었기에 cat의 eat출력 파이썬 - 리스트 컴프리헨션
arr = [1, 2, 3, 4, 5]
result = [arr.pop(0) * i for i in arr if i% 2 == 1]
print(result);0result = [arr.pop(0) * i for i in arr if i% 2 == 1]
1. i for i in arr if i% 2 == 1
//i는 arr의 값을 가져와야한다.
//첫번째 i가 배열 값 1 - 1 % 2 == 1
//arr에서 pop(0) = 1을 가져온다. arr = [2, 3, 4, 5]
//1*1 = 1 result = [1]
2. //두번째 2 % 2 = 0 X
3. //세번째 i는 배열 값 3 - 3 % 2 = 1
//arr에서 pop(0) = 2를 가져온다. arr = [3, 4, 5]
//2 * 3 = 6 result = [1, 6]
4. //i가 4일때 4 % 2 = 2
5. //i가 5일때 5 % 2 = 1
//arr에서 pop(0) 가져온다. arr = [4, 5]
//3 * 5 = 15 result = [1, 6, 15]
6. print(result);
//따라서 [1, 6, 15]C언어 - ~연산자
int a1 = 6;
int a2 = -6;
int b = 5;
int result1 = (a1 & b) | (~a1);
int result2 = (a2 & b) | (~a2);
printf("양수 : %d\n", result1);
printf("음수 : %d\n", result2);
/*
음수 바꾸는 법
0을 1로 1을 0으로 바꾸고 +1
양수로 바꾸는법
0을 1로 1을 0으로 바꾸고 +1
*/
양수 : -3
음수 : 5
C언어 - union
char i;
union {
int int_arr[2];
char char_arr[8]
} endian;
for(i=0; i<8; i++)
endian.char_arr[i]=i+16;
print("%x", endian.int_arr[1]);
union - 멤버들이 같은 메모리 공간을 사용
char형 1 바이트 char_arr 8바이트
int_arr 4바이트 2개
char_arr
16 17 18 19 20 21 22 23
int_arr[0] = 16 17 18 19
int_arr[1] = 20 21 22 23
%x = 16진수로 표현 -> 14, 15, 16, 17
print("%x", endian.int_arr[1]);
리틀 엔디안 방식으로 사용하는 시스템 이라면
17161514 C언어 - 재귀함수
int rec(int n){
int sum;
if(n>2) {
sum = rec(n-1) + rec(n-2);
printf("%d", sum);
}
else
sum = n;
return sum;
}
int result;
result = rec(5);
printf("%d", result); r(5)
/
/
r(4) + r(3)
/ \
/ \
r(3) + r(2) r(2) + r(1)
/
/
r(2) + r(1)
r(2) + r(1)
s:2 s:1
r(3) -> sum = 2+1 //3 출력 r(3) = 3
r(3) + r(2) //r(3)=3 r(2)=2
r(4) -> sum = 3+2 //5 출력 r(4) = 5
r(4) + r(3) //r(4) = 5 r(3) = 3
오른쪽 r(3)의 sum = 2+1 //3 출력 전반적으로 sum으로 합으로 인해 발생되면 출력해야함
r(4)의 sum = 5+3 //8 출력
printf("%d", result); ///r(5) 8 출력35388
void func(int a, int b, int c)
{
if(c!=0)
fun(b, a+b, c-1);
printf("%d, %d, %d \n", a,b,c);
}
}
int i=1, j=1, k=3;
fun(i, j, k);fun(i, j, k);
a=1, b=1, k=3
fun(b, a+b, c-1);
//fun(1, 2, 2); 1, 1, 3 저장
fun(b, a+b, c-1);
//fun(2, 3, 1); 1, 2, 2 저장
fun(b, a+b, c-1);
//fun(3, 5, 0); //c!=0이라 종료 2, 3, 1 저장
//모든 fun 재귀함수가 끝나서 print 실행
printf("%d, %d, %d \n", a,b,c);
//스택형이라 마지막부터 출력
2, 3, 1
1, 2, 2
1, 1, 3C언어 - 포인트 1차원 배열
int a[3] = {-3, 14, 5}; //1차원 배열
int *p = &a[1];
printf("%d ", a[1]);
printf("%d ", p[1]); a 100
&a 100
&a[0] 100
int *p = &a[1];//a[1] 104 주소 값을 받는다.
printf("%d, ", a[1]); //14,
printf("%d ", p[1]); //5
//첫번째 시작하는 것이 0번 인덱스이다.
//따라서 p 입장에서 104주소값을 가진 14가 0 인덱스가 된다.
14, 5C언어 - 포인트 2차원 배열
int a[2][3] = {{-3, 14, 5} , {1, -10, 8}};
int *p = &a[1];
printf("%d, ", a[1][1]);
printf("%d " , p[1]);-3 14 5
1 -10 8
a[0] -3 14 5 //-3이 주소가 100이라고 함
a[1] 1 -10 8 // 1의 주소가 112라고 함
//-3이 a[0]의 대표 주소 100, 1이 a[1]의 대표 주소 112
int *p = a[1]; //a[1]의 주소 값을 112 저장
printf("%d, ", a[1][1]); //-10 출력
printf("%d " , p[1]); //p[1]은 112 주소를 저장 대표인 a[1]의 위치의 1번 인덱스 -10 출력
-10, -10int a[2][3] = {{-3, 14, 5} , {1, -10, 8}};
int *b[] = {a[0], a[1]};
int *p = b[1];
printf("%d, ", *b[1]);
printf("%d, ", *(++p));
printf("%d", *(--p-2));a[0] -3 14 5 //-3이 주소가 100이라고 함
a[1] 1 -10 8 // 1의 주소가 103라고 함
//-3이 a[0]의 대표 주소 100, 1이 a[1]의 대표 주소 103
int *b[] = {a[0], a[1]};
//b에 100번지, 103번지 저장
int *p = b[1];
//p의 a[1]의 103번지 저장
printf("%d, ", *b[1]); //103번지 1 출력
printf("%d, ", *(++p)); //103번지의 전위 연산자는 p의 내에도 대입 된다.
//p: 103 -> 104 104번지 -10 출력, p 104
printf("%d", *(--p-2));
//p 104 --p하면 103이 되지만 -2는 대입이 되지않는다. 101번 14 출력 되며 p의 주소는 103
1, -10, 14 C언어 - 구조체
#include<studio.h>
int main(){
struct list{
int *fp;
} data, *p //data - *fp 구조체 변수 선언
//*p 포인터 변수 선언
int x[] = {100, 200, 300 ,400};
p = &data;
p -> fp = x + 1
printf("%d", *(++p->fp));
return 0;
} data - *fp //2000번지
*p //3000번지
int x[] = {100, 200, 300 ,400};
100 - 1000번지
200 - 1001번지
300 - 1002번지
400 - 1003번지
p = &data; //p에 data의 주소값 2000번을 넣는다. p는 포인터 변수 위에 선언했기 때문
p->fp = x+1; //data가 가지고있는 fp에 x+1 1000+1 1001번지를 저장
//일반 변수는 p.fp 포인터 변수는 p->fp
printf("%d", *(++p->fp));
//data의 fp가 1002번지 300 출력
300C언어 - 더블 포인터
int x = 5, y = 10;
int *p1 = &x;
int *p2 = &y;
int **dptr = &p1;
**dptr += 2;
*dptr = p2;
**dptr *= 3;
printf("%d, %d, %d, %d\n", x, y, *p1, *p2); x의 주소값 100 = 5
y의 주소값 200 = 10
100 x 5
200 y 10
300 p1 100
400 p2 200
500 dptr 300
int *p1 = &x; //p1에 100번 저장 p1의 주소값은 300
//why? p1 포인터 변수가 메모리상으로 올라가기에
int *p2 = &y; //p2에 200번 저장, p2는 400번지
int **dptr = &p1; //dptr에 p1의 주소값 300번지 저장 dptr의 주소값은 500
**dptr += 2; //*300 - 300번지의 값 - *100 - 100번지의 값 -> 5+2=7 x=7
*dptr = p2; //*300 - 300번지의 값에다가 p2의 값을 넣는다.
//300 p1 200 - p2를 200을 넣는다
**dptr *= 3; //*300 -> *200 -> 10*3 = 30 y = 30
printf("%d, %d, %d, %d\n", x, y, *p1, *p2);
7, 30, 30, 30언어 별 true false
C언어
1
0
자바
true
false
파이썬
True
False
JAVA - 객체 생성시 변수 초기화
class Parent {
public Parent(){
System.out.println("1");
display();
}
public void display(){
System.out.println("Super");
}
}
class Child extends Parent {
private String info = "Child Info";
private int count = 100;
public Child(){
System.out.println("2");
}
public void display(){
System.out.println(info);
System.out.println(count);
}
}
public static void main(String[] args){
Parent obj1 = new Parent();
Parent obj2 = new Child();
}1. main의 Parent obj1 = new Parent(); //생성자 생성
//부모 메모리 초기화
//부모 생성자 실행
2. public Parent(){ //생성자가 실행 된다.
System.out.println("1"); //1 출력
display(); //display 메서드 실행
}
3. Parent()의 display
public void display(){
System.out.println("Super"); //Super 출력
}
}
4. main의 Parent obj2 = new Child(); //생성자 실행
public Child(){ //super가 없기에 부모의 default 생성자 자동 호출
System.out.println("2");
}
5.
public Parent(){
System.out.println("1"); //1 출력
display(); //생성자 Child의 최종적으로 오버라이딩한 메서드를 호출
}
6. Child의 display 메서드
public void display(){
System.out.println(info); //null 출력
System.out.println(count); //0 출력
//아직 부모의 메서드가 끝나지 않아서 아직
//자식 생성자가 생성되지않아 멤버 변수가 메모리상에 저장되지 않았다.
}
7. public Child(){
//obj2의 멤버 변수를 초기화 메모리상에 저장
//obj2 생성자 실행
System.out.println("2"); //2출력
1
Super
1
null
0
2C언어 주요 함수
malloc - 동적으로 메모리 할당
calloc - 할당된 메모리 공간을 0으로 초기화
realloc - 이미 할당된 메모리 크기를 변경
free() - 동적으로 할당된 메모리 해제
문자열 처리 함수 <string.h>
strcpy(dest, src) - src 문자열을 dest로 복사
strncpy(dest, src, n) - src 문자열의 처음 n개 문자를 dest로 복사
strcat(dest, src) - src문자열을 dest 뒤에 붙임
strncat(dest, src, n) - src문자열의 처음 n개 문자를 dest 뒤에 붙임
strcmp(s1, s2) - 두 문자열 s1과 s2 비교 → 같으면 0, s1이 크면 양수, s2가 크면 음수 출력
strncmp(s1, s2, n) - 두 문자열의 처음 n개 문자를 비교
strlen(s) - 문자열 s의 길이 반환
수학 함수 <math.h>
sqrt(x) - x의 제곱근을 반환
pow(base, exp) - base의 exp 제곱을 반환
fabs(x) - x의 절대값 반환
union - 여러 자료형의 변수들이 메모리 공간을 공유하는 자료형
python
chr(i) - 정수 값 i에 해당하는 문자를 반환 ex) chr(65) → A
ord(c) - c에 해당하는 ASCII 정수 값으로 반환 → 67
len(s) - 길이 반환
str.upper() - 대문자
str.lower() - 소문자
str.strip() - 공백 제거
str.split() - 문자열을 특정 구분자를 기준으로 분리하여 리스트로 반환
str.join(list) - 리스트의 문자열을 특정 구분자로 연결하여 하나의 문자열로 만듬
수학 함수
abs(x) - 절대값 반환
max() - 최대값 반환
min() - 최솟값 반환
sum() - 합
round(x, n) - x를 n번째 소수점 자리에서 반올림
divmod(a, b) - a를 b로 나눠 (몫, 나머지) 반환
컬렉션 함수
append() - 리스트 끝에 요소 추가
insert(index, item) - 리스트의 특정 위치에 요소를 삽입
pop() - 리스트의 마지막 요소 또는 특정 인덱스의 요소를 제거하고 반환
remove(item) - 리스트에서 특정 값을 가진 첫 번째 요소를 제거
sort() - 리스트 정렬
sorted(iterable) - iterable 객체를 정렬한 새로운 리스트를 반환
keys() - 딕셔너리의 모든 키를 반환
values() 딕셔너리의 모든 값을 반환
items() - 딕셔너리의 모든 키- 값 쌍을 반환
