반응형
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
// ConsoleApplication1.cpp: 콘솔 응용 프로그램의 진입점을 정의합니다.
//
 
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
 
int main()
{
    /*
    int data[3] = {10,20,30};
    printf("data의 값 : %d\n",data); // 인덱스는 첫번째 원소의 주소이다.
    */
 
    int data[3][3]={
    { 10,20,30 },
    { 40,50,60 },
    { 70,80,90 }
    };
    printf("data : %d \n", data);
    printf("*data : %d \n"*data); // 포인터로 접근 주소값이 출력됨.
    printf("**data : %d \n"**data); // data[0][0]의 값이 출력됨
    printf("*(*data+1) : %d \n"*(*data+1)); 
    printf("**(data + 1) : %d \n"**(data + 1));
    printf("(**data + 1) : %d \n", (**data + 1));
 
 
    /* // 배열로 접근
    printf("data 의 값은 : %d \n", data);
    printf("data[0] 의 값은 : %d \n", data[0]);
    
    printf("data[0][0] 의 값은 : %d \n", &data[0][0]);
    printf("data[1] 의 값은 : %d \n", data[1]);
    printf("data[2] 의 값은 : %d \n", data[2]);
    */
    
    return 0;
}
 
 
cs

 

 

출력 결과 :

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
 
int main()
{
    int data[3][3]={
    { 10,20,30 },
    { 40,50,60 },
    { 70,80,90 }
    };
 
    printf("%d\n"*(*(data + 1+ 2));
    printf("%d\n"*(*(data + 2+ 2));
    printf("%d\n"*(*(data+2)+1));
 
    printf("%d\n"*(data[1+ 2));
    printf("%d\n"*(data[2+ 2));
 
    // 즉 *(data[1] + 2)  = *(*(data + 1) + 2) 이다
    return 0;
}
cs

출력 결과 :

 

 

 

반응형
반응형
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
 
int main()
{
    int A = 100;
    int *pA = &A;
    int **ppA = &pA;
    int ***pppA = &ppA;
 
    printf("변수 A의 값(주소) : %d (%d)\n", A, &A);
    printf("변수 pA의 값(주소) : %d (%d)\n", pA, &pA);
    printf("변수 ppA의 값(주소) : %d (%d)\n", ppA, &ppA);
 
    printf("\n\n 포인터가 가르키는곳에는? \n");
    printf("ppA가르키는 값(주소) : %d\n"*ppA);
    printf("pA가르키는 값(주소) : %d\n"*pA);
 
    return 0;
}
 
cs

 

출력결과

 

반응형
반응형
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
 
int main()
{
    unsigned char data = 0xfe;
    char str[100];
    int mode = 0;
 
    while (1) {
 
        system("cls");
        _itoa_s(data, str, 2);
        if (strlen(str) < 8) {
            for (int i = 0; i < 8 - strlen(str); i++printf("0");
        }
 
        if (mode == 0) {
            data = ~data;
            data = data << 1;
            data = ~data;
            if (data == 127)
                mode = 1;
        }
        else if (mode == 1) {
            data = ~data;
            data = data >> 1;
            data = ~data;
            if (data == 254)
                mode = 0;
        }
        printf("%s", str);
 
        
        
            
        Sleep(500);
    }
    return 0;
}
cs
반응형

'Study > C' 카테고리의 다른 글

C언어 - 2차원배열 과 포인터  (0) 2018.08.29
C언어 - 이중 포인터  (0) 2018.08.29
C언어 - 비트연산2 (1을 이동시키기)  (0) 2018.08.29
C언어 - 비트 연산  (0) 2018.08.29
C언어 - Tictactoe 게임  (0) 2018.08.28
반응형

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
 
int main()
{
    unsigned char data = 1;
    char str[100];
    int mode = 0;
 
    while (1) {
 
        system("cls");
        _itoa_s(data, str, 2);
        if (strlen(str) < 8) {
            for (int i = 0; i < 8 - strlen(str); i++printf("0");
        }
 
        if (mode == 0) {
            data = data << 1;
            if (data == 128)
                mode = 1;
        }
        else if (mode == 1) {
            data = data >> 1;
            if (data == 1)
                mode = 0;
        }
        printf("%s", str);
 
        printf("\n%d", data);
        
            
        Sleep(500);
    }
    return 0;
}
 
cs
반응형

'Study > C' 카테고리의 다른 글

C언어 - 이중 포인터  (0) 2018.08.29
C언어 - 비트연산3 (0을 이동시키기)  (0) 2018.08.29
C언어 - 비트 연산  (0) 2018.08.29
C언어 - Tictactoe 게임  (0) 2018.08.28
C언어 - 블럭 옴기기 게임  (0) 2018.08.28
반응형
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
 
int main()
{
    unsigned char data = 182;
    int bit_loc = 0;
    unsigned char bit_result = 0;
 
    while (1) {
 
        char str[100];
        _itoa_s(data, str, 2);
 
        system("cls");
        printf("%s", str);
        printf("\n몇번 비트를 확인 할 까요 ? : ");
 
        scanf_s("%d"&bit_loc);
 
        bit_result = data >> bit_loc;
        bit_result = bit_result & 0x01;
 
        
        if (bit_result) {
            data = data & (~(1 << bit_loc));
        }
        else {
            data = data | (1 << bit_loc);
        }
        // if문 수식을 3항 연산자로 간결하게 할 수 있다.
        //data = (bit_result == 1) ? data & (~(1 << bit_loc)) : data | (1 << bit_loc);
    }
    return 0;
}
 
 
cs

 

반응형

'Study > C' 카테고리의 다른 글

C언어 - 비트연산3 (0을 이동시키기)  (0) 2018.08.29
C언어 - 비트연산2 (1을 이동시키기)  (0) 2018.08.29
C언어 - Tictactoe 게임  (0) 2018.08.28
C언어 - 블럭 옴기기 게임  (0) 2018.08.28
C언어 - 배열 포인터  (0) 2018.08.28
반응형

#include "stdafx.h"
#include <stdio.h>
#include "myfunc.h"
#include <random>
using namespace std;
#include <conio.h>

#define LEFT 75
#define RIGHT 77
#define UP 72
#define DOWN 80
#define SPACE 32


int main()
{
 int board[3][3] = { 0 };
 int count = 0;
 int x = 0, y = 0;
 int inputkey = 0;
 int tmp = 0;
 

 for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
   count++;
   board[i][j] = count;
  }
 }
 
 while (1) {
  
  system("cls");
  
  printf(" ────────\n");
  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    setColor(BLACK, WHITE);
    printf("│");
    if (board[i][j] == 1) {
     x = i; y = j;
     setColor(RED, WHITE);
    }
    else {
     setColor(BLACK, WHITE);
    }
    printf("%2d", board[i][j]);
    setColor(BLACK, WHITE);
    printf("│");
   }
   printf("\n ────────\n");
  }
  Sleep(50);

  inputkey = _getch();

  
  

 }
 
 return 0;
}

 

// 미완성

=================================================================================================

//완성 소스

#include "pch.h"
#include "myFunc.h"
#include <stdlib.h>
#include <conio.h>
#include <random>

using namespace std;

#define MAX 3
#define LE 75
#define RI 77
#define UP 72
#define DO 80
#define SPACE 32

#define ME 0
#define COM 1

int main()
{
 random_device rn;
 mt19937_64 rnd(rn());
 uniform_int_distribution<int> range(0, MAX - 1);

 // tic-tac-toe variables
 int board[MAX][MAX] = {0,};
 int cursor_x = 0, cursor_y = 0;
 int com_x = 0, com_y = 0;
 int inputKey = 0;
 int turn = 0;
 
 while (1)
 {
  // Drawing
  system("cls");
  setColor(BLACK, WHITE);
  printf("\n  ┌───┬───┬───┐\n");
  for (int y = 0; y < MAX; y++)
  {   
   printf("  │");
   for (int x = 0; x < MAX; x++)
   {
    if (x == cursor_x && y == cursor_y)
    {
     setColor(BLACK, RED);
     if (board[y][x] == 0) printf(" ↖");
     else if (board[y][x] == 1) printf(" ○");
     else if (board[y][x] == 2) printf(" Ⅹ");
     setColor(BLACK, WHITE);
    }
    else if (board[y][x] == 0) printf("   ");
    else if (board[y][x] == 1) printf(" ○");
    else if (board[y][x] == 2) printf(" Ⅹ");
    if (x < (MAX - 1)) printf("│");
   }
   printf("│");
   if (y < (MAX - 1)) printf("\n  ├───┼───┼───┤\n");
  }
  printf("\n  └───┴───┴───┘\n");  

  // Game Checking


  // input (Player Turn)
  inputKey = _getch();
  if (inputKey == LE) cursor_x--;
  else if (inputKey == RI) cursor_x++;
  else if (inputKey == UP) cursor_y--;
  else if (inputKey == DO) cursor_y++;
  else if (inputKey == SPACE)
  {
   if (turn == ME)
   {
    if (board[cursor_y][cursor_x] == 0)
    {
     board[cursor_y][cursor_x] = 1;
     turn = COM;
    }
   }
  }

  // COM Turn
  if (turn == COM)
  {
   int comDone = 1;
   while (comDone)
   {
    com_x = range(rn);
    com_y = range(rn);
    if (board[com_y][com_x] == 0)
    {
     board[com_y][com_x] = 2;
     comDone = 0;
     turn = ME;
    }
   }   
  } 
 }
}

반응형

'Study > C' 카테고리의 다른 글

C언어 - 비트연산2 (1을 이동시키기)  (0) 2018.08.29
C언어 - 비트 연산  (0) 2018.08.29
C언어 - 블럭 옴기기 게임  (0) 2018.08.28
C언어 - 배열 포인터  (0) 2018.08.28
C언어 - 포인터 2  (0) 2018.08.28
반응형

#pragma once


#include <conio.h>
#include <windows.h>

#define LEFT 75
#define RIGHT 77
#define UP 72
#define DOWN 80
#define SPACE 32


#define BLACK 0
#define BLUE 1
#define GREEN 2
#define IVORY 3
#define RED 4
#define PURPLE 5
#define YELLOW 6
#define WHITE 7
#define GRAY 8
#define SKYBLUE 9
#define YELLOWGREEN 10
#define WHITEIVORY 11
#define PINK 12
#define WHITEPURPLE 13
#define WHITEYELLOW 14
#define BOLDWHITE 15

#define BOARD_SIZE 5

void setColor(int background, int foreground)
{
 SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), (background << 4) | foreground);
}

 

// myfunc

 

 

#include "stdafx.h"
 #include <stdio.h>
 #include "myfunc.h"
 #include <random>
 using namespace std;
 #include <conio.h>

 #define LEFT 75
 #define RIGHT 77
 #define UP 72
 #define DOWN 80
 #define SPACE 32

 int main()
 {
  random_device rn;
  mt19937_64 rnd(rn());
  uniform_int_distribution<int> range(0, 2); // 1부터 45사이에서 출력한다.

  int board[3][3] = { 0 };
  int result[3][3] = { 0 };
  int count = 0;
  int ran1 = 0, ran2 = 0;
  int ran3 = 0, ran4 = 0;
  int tmp = 0;
  int inputkey = 0;
  int x = 0, y = 0;
  int gameFlag = 1;
  int resultcount = 0;
  int debugcount = 0;

  for (int i = 0; i < 3; i++) {
   for (int j = 0; j < 3; j++) {
    count++;
    board[i][j] = count;
    result[i][j] = count;
   }
   printf("\n");
  }
  count = 0;

  for (int i = 0; i < 100000; i++) {

   ran1 = range(rn);
   ran2 = range(rn);
   ran3 = range(rn);
   ran4 = range(rn);

   tmp = board[ran1][ran2];
   board[ran1][ran2] = board[ran3][ran4];
   board[ran3][ran4] = tmp;
  }

  while (gameFlag) {

   system("cls");
   
   resultcount = 0;
   for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
     if (board[i][j] == result[i][j])
      resultcount++;
    }
   }

   for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {

     if (board[i][j] == 9) {
      y = i; x = j;
      setColor(BLACK, BLACK);
      printf("%2d", board[i][j]);
     }
     else {
      if (board[i][j] % 2 == 0) {
       setColor(RED, WHITE);
       printf("%2d", board[i][j]);
      }
      else if (board[i][j] % 2 == 1) {
       setColor(BLUE, WHITE); printf("%2d", board[i][j]);
      }
     setColor(BLACK, WHITE);
     }

    }
    printf("\n");
   }
   Sleep(50);

   inputkey = _getch();
   if (inputkey == LEFT) {
    int tmp2 = 0;
    if ((x + 1) < 3) {
     tmp2 = board[y][x];
     board[y][x] = board[y][x + 1];
     board[y][x + 1] = tmp2;
     tmp2 = 0;
    }
   }
   else if (inputkey == RIGHT) {
    int tmp2 = 0;
    if ((x - 1) >= 0) {
     tmp2 = board[y][x];
     board[y][x] = board[y][x - 1];
     board[y][x - 1] = tmp2;
     tmp2 = 0;
    }
   }
   else if (inputkey == UP) {
    int tmp2 = 0;
    if ((y + 1) < 3) {
     tmp2 = board[y][x];
     board[y][x] = board[y + 1][x];
     board[y + 1][x] = tmp2;
     tmp2 = 0;
    }
   }
   else if (inputkey == DOWN) {
    int tmp2 = 0;
    if ((y - 1) >= 0) {
     tmp2 = board[y][x];
     board[y][x] = board[y - 1][x];
     board[y - 1][x] = tmp2;
     tmp2 = 0;
    }
   }
   else if (inputkey == SPACE) {
    for (int i = 0; i < 3; i++) {
     for (int j = 0; j < 3; j++) {
      debugcount++;
      board[i][j] = debugcount;
     }
    }
   }count = 0;

   if (resultcount > 8){
    gameFlag = 0;
    resultcount = 0;
    setColor(BLACK, WHITE);
    printf("정답 ! 완성하였습니다.");
   }
  }
  return 0;
 }

==============================================================================================

//교수님 소스

#include "stdafx.h"

#include "myFunc.h"
#include <stdlib.h>
#include <conio.h>
#include <random>

using namespace std;

#define MAX 5

#define LE 75
#define RI 77
#define UP 72
#define DO 80
#define SPACE 32

#define ME 0
#define COM 1

void swap(int *a, int *b)
{
 int tmp = *a;
 *a = *b;
 *b = tmp;
}

void dist(int board[MAX][MAX])
{
 random_device rn;
 mt19937_64 rnd(rn());
 uniform_int_distribution<int> range(0, MAX - 1);

 int count = 0;
 int dc1 = 0, dc2 = 0, dc3 = 0, dc4 = 0;
 for (int y = 0; y < MAX; y++)
 {
  for (int x = 0; x < MAX; x++)
  {
   board[y][x] = ++count;
   if (count == MAX * MAX) board[y][x] = 0;
  }
 }
 for (int i = 0; i < 1000; i++)
 {
  dc1 = range(rn);
  dc2 = range(rn);
  dc3 = range(rn);
  dc3 = range(rn);
  swap(board[dc1][dc2], board[dc3][dc4]);
 }
}

int main()
{
 // tic-tac-toe variables
 int board[MAX][MAX] = { 0, };
 int cursor_x = 0, cursor_y = 0;
 int inputKey = 0;

 dist(board);
 while (1)
 {
  // Drawing
  system("cls");
  printf("\n");
  for (int y = 0; y < MAX; y++)
  {
   printf("   ");
   for (int x = 0; x < MAX; x++)
   {
    if (board[y][x] == 0)
    {
     setColor(BLACK, WHITE);
     printf("    ");
     cursor_x = x;
     cursor_y = y;
    }
    else if (board[y][x] % 2 == 0)
    {
     setColor(RED, WHITE);
     printf("%3d ", board[y][x]);
    }
    else
    {
     setColor(BLUE, WHITE);
     printf("%3d ", board[y][x]);
    }

    setColor(BLACK, WHITE);
   }
   printf("\n");
  }

  // input
  inputKey = _getch();
  if (inputKey == LE)
  {
   if (cursor_x >= 0 && cursor_x < (MAX - 1))
   {
    board[cursor_y][cursor_x] = board[cursor_y][cursor_x + 1];
    board[cursor_y][cursor_x + 1] = 0;
    cursor_x--;
   }
  }
  else if (inputKey == RI)
  {
   if (cursor_x <= MAX - 1 && cursor_x > 0)
   {
    board[cursor_y][cursor_x] = board[cursor_y][cursor_x - 1];
    board[cursor_y][cursor_x - 1] = 0;
    cursor_x++;
   }
  }
  else if (inputKey == UP)
  {
   if (cursor_y >= 0 && cursor_y < (MAX - 1))
   {
    board[cursor_y][cursor_x] = board[cursor_y + 1][cursor_x];
    board[cursor_y + 1][cursor_x] = 0;
    cursor_y--;
   }
  }
  else if (inputKey == DO)
  {
   if (cursor_y <= MAX - 1 && cursor_y > 0)
   {
    board[cursor_y][cursor_x] = board[cursor_y - 1][cursor_x];
    board[cursor_y - 1][cursor_x] = 0;
    cursor_y++;
   }
  }
  else if (inputKey == SPACE)
  {
   // Cheat
   int tmpCount = 0;
   for (int i = 0; i < MAX; i++)
   {
    for (int j = 0; j < MAX; j++)
    {
     board[i][j] = ++tmpCount;
     if (tmpCount == MAX * MAX) board[i][j] = 0;
    }
   }
  }
 }
}

 

반응형

'Study > C' 카테고리의 다른 글

C언어 - 비트 연산  (0) 2018.08.29
C언어 - Tictactoe 게임  (0) 2018.08.28
C언어 - 배열 포인터  (0) 2018.08.28
C언어 - 포인터 2  (0) 2018.08.28
C언어 - 포인터  (0) 2018.08.28
반응형

// ** 포인터 배열을 사용하여 로또 6자리 출력하기

 

#include "stdafx.h"
#include <stdio.h>
#include <random>
using namespace std;


int main()
{
 random_device rn;
 mt19937_64 rnd(rn());
 uniform_int_distribution<int> range(1, 45);

 // 랜덤수 출력 함수


 int data[45] = { 0 };
 int dice = 0, count = 0;
 for (int i = 1; i <= 45; i++) {
  *(data + (i - 1)) = i;
 }

 while (count < 6) {

  dice = range(rn);

  if (*(data + dice) != 0) {
   printf("\n%d  ", *(data + dice));
   *(data + dice) = 0;
   count++;
  }

 }
 return 0;
}

========================================================================

 

** 포인터 배열을 사용하는 경우

 

1. SWAP함수 처럼 사용할 경우

2. 하드웨어적으로 직접적으로 주소값을 수정할 경우.

3. 메모리 동적할당

 

========================================================================

 

// swap함수 없이 45개 배열 숫자 섞기 셔플방식


#include "stdafx.h"
#include <stdio.h>
#include <random>
using namespace std;


int main()
{
 random_device rn;
 mt19937_64 rnd(rn());
 uniform_int_distribution<int> range(0, 44);

 // 랜덤수 출력 함수


 int data[45] = { 0 };
 int dice = 0, count = 0;
 for (int i = 1; i <= 45; i++) {
  *(data + (i - 1)) = i;
 }

 int ran1 = range(rn), ran2=range(rn);
 int tmp =0 ;
 for (int i = 0; i < 10000; i++) {
  ran1 = range(rn), ran2 = range(rn);
  tmp = *(data + ran1);
  *(data + ran1) = *(data + ran2);
  *(data + ran2) = tmp;
 }

 for (int i = 0; i < 45; i++) {
  printf("%d  ",data[i]);
 }
 return 0;
}

 

========================================================================

 

// 메모리 동적 할당.


#include "stdafx.h"
#include <stdio.h>
#include <random>
using namespace std;


int main()
{
 int enemy_qu = 0;
 printf("몇 명의 적 출현 시킬까요 ? : ");
 scanf_s("%d",&enemy_qu);

 // 메모리 동적 할당
 int *enemy = new int[enemy_qu];

 // 적 출현
 for (int i = 0; i < enemy_qu; i++) {
  *(enemy + i) = i * 10;
  printf("%d ", *(enemy + i));
 }
 //동적할당 메모리 삭제
 delete enemy;
 return 0;
}

 

반응형

'Study > C' 카테고리의 다른 글

C언어 - Tictactoe 게임  (0) 2018.08.28
C언어 - 블럭 옴기기 게임  (0) 2018.08.28
C언어 - 포인터 2  (0) 2018.08.28
C언어 - 포인터  (0) 2018.08.28
C언어 - Rullet 게임 만들기 2  (0) 2018.08.28
반응형

** 이중 포인터

 

 

int A = 0;

int *pA = &A;

int **ppA = &pA;

 

printf("%d\n",**ppA);

 

================================================================================

 

int A = 0;

int *pA = &A;

int **ppA = &pA;

 

printf("%d\n", A);
printf("%d\n", &A);
printf("%d\n", *pA);
printf("%d\n", **ppA);

 

// 출력 결과

 

 

================================================================================

 

 

** 배열 포인터

 


 int a[5] = { 1,2,3,4,5 };


 printf("%d %d %d %d %d ", a, &a[0], &a[1], &a[2], &a[3]); // a와 &a[0] 값은 같다.


 printf("\n%d", *(a + 1)); // a의 주소값+1

 

 

 

 

 

int data[10];

 

printf("%d", data); // 주소값이 출력된다.

 

 

// data[0] 이나 *data나 같다.

 

 

** 포인터 배열을 사용하여 배열을 직접 건드리지 않고 값을 입력받아 큰수와 작은수를 찾아 준다.


int data[10] ;
int min =0, max=0;

 

for (int i = 0; i < 10; i++) {

printf("키를 입력해 주세요 : "); 

scanf_s("%d", (data + i));
}

 

// data , data+1

// 주소값에 1을 더할 경우 4바이트 증가한다.

 

min = *data; // 첫번째 값을 넣어준다

 

for (int i = 0;i<10; i++){

if (*(data+i)>max)max =*(data+i);

if (*(data+i)<min)min =*(data+i);

}

 

printf("가장 큰 수는 : %d ",max);

printf("가장 작은 수는 : %d ",min);

 

반응형

'Study > C' 카테고리의 다른 글

C언어 - 블럭 옴기기 게임  (0) 2018.08.28
C언어 - 배열 포인터  (0) 2018.08.28
C언어 - 포인터  (0) 2018.08.28
C언어 - Rullet 게임 만들기 2  (0) 2018.08.28
C언어 - Rullet 게임만들기  (0) 2018.08.27
반응형

** 포인터

 

&a : a의 주소값 // 실행 할 때 마다 주소값이 바뀜.

 

예)

int A = 10;

int *pA =100; // 일반값은 들어가지 않는다. 주소값만 들어간다.

int *pA = &A; // A의 주소값을 넣었다.

 

printf("A의 값 %d\n" , A);

printf("A의 주소값 %d\n" , &A);

printf("pA의 값 %d\n" , pA);

 

 

 

 

// A에는 일반 값을 가질 수 있다.

// *pA 포인터 변수에는 변수의 주소

 

값만 가질 수 있다.

 

printf("pA가 가르키는 값 %d\n",*pA);

 

 

포인터를 사용하면 특정 변수를 간접적으로 변경할 수 있다.

 

** Call by reference

 

 

** C언어는 기본적으로 Call by value

 

void swap (int a, int b){

int tmp =a;

a =b;

b=tmp;

}

int main(){
int data1 =10;

int data2 =20;

swap(data1,data2);

}

 

// 출력결과 데이터값이 바뀌지 않고 10,20으로 출력된다.

// swap함수를 쓰고 싶다면, 포인터를 이용한다.

 

void swap(int *a, int *b){

int tmp = *a;

*a=*b;

*b=tmp;

}

int main(){

int data1 = 10;

int data2 = 20;

swap(&data1, &data2);

}

 

// swap되어 출력된다.

 

*a : 포인터 변수 // a의 주소를 사용하겠다는 의미

&a : a의 주소값

 

** 전역변수를 써서 사용할 수도 있지만, 함수 코드를 공유할 때, 전역변수 까지 전달해야하는 번거로움이 있다.

// 포인터 함수를 사용하면 좀 더 편리하다.

 

 

 

 

void swap(int *a, int *b){  // int *a와 int *b 에 주소값을 저장한다.

int tmp = *a;  // tmp에 *a값을 저장한다. (주소값 X)

*a=*b;  // *a에 *b값을 저장한다.  (주소값 X)

*b=tmp; // *b에 tmp값을 저장한다.  (주소값 X)

}

 

 

int *pA = (int *) (300); // 포인터 변수 *pA의 주소값을 300으로 설정한다.

 

int *pA = &A; // A의 주소값을 넣었다.

 *pA = 1000; // A의 값에 1000을 넣었다.

 

 

반응형

'Study > C' 카테고리의 다른 글

C언어 - 배열 포인터  (0) 2018.08.28
C언어 - 포인터 2  (0) 2018.08.28
C언어 - Rullet 게임 만들기 2  (0) 2018.08.28
C언어 - Rullet 게임만들기  (0) 2018.08.27
C언어 - 난수 발생함수(random함수)  (0) 2018.08.27

+ Recent posts