🤳 [C]_23.03.22

구조체

10-9.c

//// 10-9 풀이 
//
//
//#define _CRT_SECURE_NO_WARNINGS    // strcpy, strcat 보안 경고로 인한 컴파일 에러 방지
//#include <stdio.h>
//#include <string.h>    // strcpy, strcat 함수가 선언된 헤더 파일
//
//
//int main()
//{
//    char s1[10] = "world";                  // 크기가 10인 char형 배열을 선언하고 문자열 할당
//    char* s2 = malloc(sizeof(char) * 20);    // char 20개 크기만큼 동적 메모리 할당
//
//    strcpy(s2, "Hello");   // s2에 Hello 문자열 복사
//
//    strcat(s2, s1);        // s2 뒤에 s1을 붙임
//
//    printf("%s\n", s2);    // Helloworld
//
//
//    return 0;
//}


#include <stdio.h>

void my_Strcat(char* dest, char* source);

int main() {
	char strDestination[20] = "king";
	char strSource[20] = "dom";

	my_Strcat(strDestination, strSource);

	printf("Source: %s ,  Destination: %s\n", strSource, strDestination);
}

void my_Strcat(char* dest, char* source) {
	for (; *dest; dest++);
	for (; *source; dest++, source++) {
		*dest = *source;
	}
	*dest = '\0';
}

11_9.c

//11_9.c
#include<stdio.h>

struct EMP {
	char name[20];
	int age;
	int salary; 

}emps[4] = { {"진달래", 20, 500000}, {"개나리", 23, 600000}, {"까꿍이", 27, 700000}, {'\0'}}; //배열을 전역으로 선언 

 
// struct emp* ptr; // *ptr; 


int main()  
{
	struct EMP* ptr, tmp;
	ptr = emps; //구조체 변수는 멤버들의 집합 

	//while (*ptr->name) // 주소는 항상 참이므로 무한루프, null을 만날 때까지만 출력하려면 배열의 특정 첨자(값) 지정 필 => emps 배열의 특정 인수(값)가 null 이면 break+)  ptr->name => (*ptr).name => emps.name 
	//while (*((*ptr)).name != '\0'){ // while(0) 이면 break  // *((*ptr)).name != '\0'
	
	/*while (*(*ptr).name)
	{
		printf("%s, %d, %d \n", ptr->name, ptr->age, ptr->salary);
		ptr++;
	}
	*/
	
	/*while (*ptr->name) {
		printf("%s, %d, %d \n",
			ptr->name, ptr->age, ptr->salary); //emp 배열 출력 
		ptr++; //구조체 배열의 새로운 열의 데이터 시작주소 할당통한 emp멤버 순차 출력 => emp[0], emp[1],,,
	}
	
	ptr = emps; 
	tmp = *ptr; 
	// printf("%s, %d, %d \n",tmp.name, tmp.age, tmp.salary);

	return 0; 

}
*/

//
//#include <stdio.h>
//int main()
//{
//	struct EMP {
//		char name[20];
//		int age;
//		int salary;
//	} emps[4] = { {"진달래", 20, 500000},
//	{"개나리", 23, 600000},
//	{"까꿍이", 17, 700000},{NULL} };
//	struct EMP* ptr;
//
//
//	ptr = emps;
//	printf("\n");
//
//	while (*ptr->name)
//	{
//		printf("%s, %d, %d \n", ptr->name, ptr->age, ptr->salary);
//		ptr++;
//	}
//	printf("\n");
//	return 0;
//}
//
//

struct1.c

//struct1.c

#include <stdio.h>

// 구조체(Struct) : 관련이 있는 여러 데이터들을 하나의 자료형으로 만들어 사용하게 한다. 
// 즉, 사용자 정의 자료형을 만드는 것이다. 
// 데이터들의 집합은 자료형에 구애받지 않음. 
int main()
{
	// 사용자 정의 자료형을 선언 
	// DB의 create table과 유사한 기능(field) 
	// struct 구조체 이름 {구조체 멤버들}; 
	/*struct EMPLOYEE {
		char name[20]; //구조체는 멤버의 집합 
		int salary; 
		float height; 
		char comAddr[50]; 

	} ;
	*/

	// typedef 통해 구조체 선언과 동시에 정의 
	// 태그네임인 `EMPLOYEE` 생략 가능(자료형 명이 EMP로 만들어지기 때문)
	typedef struct EMPLOYEE 
	{
		char name[20]; //구조체는 멤버의 집합 
		int salary;
		float height;
		char comAddr[60];

	} EMP;
	// 구조체 메모리 크기는 눈으로 보이는 것보다 (단순 산식) 같거나 크다 => sizeof 사용으로 확인 필 
	 
	//자료형명      //구조체변수
	struct EMPLOYEE emp = { "홍길동", 4500000, 173.5, "서울시 강남구" };
	

	EMP tmp; 

	printf("%d, %d \n", sizeof(emp), sizeof(struct EMPLOYEE)); 
	printf("%p, %p \n", &emp, emp.name); // 구조체변수는 주소값 아님 => & 사용필 ,구조체 멤버의 시작주소(첨자가 없는 배열 변수명)

	/*printf("성명 ? ");
	gets(emp.name); //공백을 입력받기 위해 gets() 사용 

	printf("월급 ? ");
	scanf_s("%d", &emp.salary); //정수, 실수값을 입력받기 위해 scanf_s() 사용  
	// 주소 대입 

	printf("키(신장) ? ");
	scanf_s("%f%*c", &emp.height);

	printf("회사 주소 ? ");
	gets(emp.comAddr);
	*/ 

	//구조체 변수이름.구조체 멤버의 이름
	printf("%s, %d, %.2f, %s \n",
		emp.name, emp.salary, emp.height, emp.comAddr); //주소가 아님, 데이터 값임
	 
	tmp = emp; 

	printf("%s, %d, %.2f, %s \n", 
		tmp.name, tmp.salary, tmp.height, tmp.comAddr); //주소가 아님, 데이터 값임

	return 0; 
}

struct2.c

//struct2.c

#include <stdio.h>
#define EMP_SZ 30  

int main()
{
	
	typedef struct EMPLOYEE
	{
		char name[20]; //구조체는 멤버의 집합 
		int salary;
		float height;
		char comAddr[60];

	} EMP;
	
	struct EMPLOYEE emp[EMP_SZ]; 
	struct EMPLOYEE* ptr;
	int i, Cn; 

	for (i = 0; i < EMP_SZ; i++)
	{
		printf("성명 ? "); //kim
		gets(emp[i].name); //emp는 1차원 배열 (열의 집합임)
		if (!strcmp(emp[i].name, "end"))
			break; 
		printf("월급 ? "); //1000
		scanf_s("%d", &emp[i].salary);
		printf("키(신장) ? "); //163
		scanf_s("%f%*c", &emp[i].height);
		printf("회사 주소 ? "); //부산시 
		gets(emp[i].comAddr); 


	}

	Cn = i; 
	ptr = emp; // 구조체 배열의 시작 주소 저장 (배열 변수는 주소값이니 `&`기재 불필요) 
	
	//구조체 배열 출력 반복문 
	for (i = 0; i < Cn; i++)
	{
		printf("%s, %d, %.2f, %s \n",
			ptr->name, ptr->salary, ptr->height, ptr->comAddr); //emp 배열 출력 
		ptr++; //구조체 배열의 새로운 열의 데이터 시작주소 할당통한 emp멤버 순차 출력 => emp[0], emp[1],,,
	}
	return 0;

}

struct3.c

//struct3.c
#include <stdio.h>


// 사용자 정의 자료형을 선언 -> 함수 안에 만들면 함수 안에서만 이용 가능  ∴ 밖에다가 선언
typedef struct EMPLOYEE {
	char name[20];
	int salary;
	float height;
	char comAddr[60];
}emp;

void funcA(struct EMPLOYEE *emp);
struct EMPLOYEE funcB(); 

int main()
{
	struct EMPLOYEE emp = { "홍길동", 4500000, 173.5, "서울시 강남구" };
	struct EMPLOYEE my;

	funcA(&emp);
	printf("실인수로 주소 전달() emps : % s, % d, % .2f, % s \n", emp.name, emp.salary, emp.height, emp.comAddr);

	my = funcB();

	printf("my : % s, % d, % .2f, % s \n", my.name, my.salary, my.height, my.comAddr);

	return 0;
}

struct EMPLOYEE funcB()
{
	struct EMPLOYEE tmp;

	tmp.salary = 370000;
	tmp.height = 163;

	*tmp.name = "진달래";		// 불가 -> *tmp.name는 4000번지 (1바이트 (char 타입)) 참조  =	 tmp.name[0] 과 동일  /   *tmp.name = 'A'; 는 가능
	strcpy(tmp.name, "진달래");				// 배열 변수는 주소 바꿀 수 없음 (포인터 상수)	/	 한글은 2바이트라 ""에 써야 함 -> ""는 주소
																// 주소에 있는 메모리에 값을 넣을 것 -> 함수 작성 혹은 라이브러리 이용
	strcpy(tmp.comAddr, "창원시 진해 벚꽃 100리");

	//printf("funcB() emps : % s, % d, % .2f, % s \n", tmp.name, tmp.salary, tmp.height, tmp.comAddr);

	return tmp;
}

void funcA(struct EMPLOYEE *emp)		// EMP emp도 가능
{
	printf("funcA() emps : % s, % d, % .2f, % s \n", emp->name, emp->salary, emp->height, emp->comAddr);
	// (*emp).name
	emp->salary += 200000;  
}

struct4.c

//struct4.c 


/* 구조체 포인터를 이용해서 두점 사이의 거리를 구하는 소스*/

//#include "stdio.h"
//#include "math.h"
//
//struct point
//{
//	int x;
//	int y;
//};
//
////구조체 포인터를 매개변수로 갖는 함수 선언
//double Get(struct point* p1, struct point* p2)
//{
//	int dx = p2->x - p1->x;
//	int dy = p2->y - p1->y;
//	return sqrt((double)(dx * dx) + (double)(dy * dy));
//}
//
//int main()
//{
//	struct point p1 = { 430,170 };
//	struct point p2 = { 120,80 };
//	double distance;
//
//	distance = Get(&p1, &p2); // 구조체 변수의 주소를 Get 함수의 인자로 전달한다.
//
//	printf("두 점 사이의 거리 : %5.2f\n", distance);
//	return 0;
//}




#include <stdio.h>
#include <math.h>

struct Point
{
	double x;
	double y;
};

double Getdistance(struct Point p1, struct Point p2)
{
	double dist;

	dist = sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));

	return dist;
}

int main()
{
	double Distance;

	struct Point p1 = { 430, 170 };
	struct Point p2 = { 120, 80 };

	Distance = Getdistance(p1, p2);

	printf("두 점 사이의 거리 : %lf \n", Distance);

	return 0;
}

struct4.1.c

//struct4.1.c 

#include <stdio.h>

typedef struct EMPLOYEE {
	char name[20];
	int salary;
	float height;
	char comAddr[60];
}EMP;

int main()
{
	struct EMPLOYEE emp = { "홍길동", 4500000, 173.5, "서울시 강남구" }; //EMP emp = { "홍길동", 4500000, 173.5, "서울시 강남구" };
	struct EMPLOYEE* ptr; // EMP *ptr

	printf("%d, %d \n", sizeof(emp), sizeof(ptr));  //100byte, 4byte  // ptr : 구조체 포인터 변수 
	
	ptr = &emp; //구조체 변수의 시작 주소는 &emp 

	// 구조체 포인터 변수가 멤버에 접근하려면 “구조체포인터변수->멤버명”으로 사용한다. , `(*ptr).`과 같은 역할 수행 
	printf("%s, %d, %.2f \n", ptr->name, ptr->salary,
								ptr->height, (*ptr).comAddr); // *(ptr+0) = ptr[0]  

	/* printf("%s, %d, %.2f \n", (*ptr).name, (*ptr).salary,
	(*ptr).height, (*ptr).comAddr);*/ 


}

파일 입출력

ref

• C 언어 파일 입출력
  https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=sharonichoya&logNo=220502134809

// fgets(str, sizeof(str), fp);
// 파일포인터(fp)와 연결된 파일로부터 주어진 바이트 수에따라
// 데이터를 읽어와서 tmp로 주어진배열에 저장한다.

• 콘솔 입출력과 파일 입출력
  https://pgh268400.tistory.com/357

• https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=tipsware&logNo=221558259987

파일에 데이터 입출력을 위한 작성 순서

• 파일에 데이터 입출력을 위한 작성 순서
  • ①파일 명 대신 파일 포인터를사용
  • FILE *파일포인터;
  • ②파일을 읽기와 쓰기 중 어떤 용도로 사용할 것인지를 결정하여 “모드” 에 기술하고 파일을 열기
  • 파일포인터= fopen("파일명“, ”모드“);
  • ③파일처리: 파일입출력
  • ④파일닫기:
    fclose(파일포인터변수);
  • FILE 구조체는 stdio.h 헤더 파일에 선언
    스트림에 접근하기 위한 자료구조로 각 스트림마다 자신만의 FILE 구조체를갖음

• 파일 입출력 과정

  • 파일 스트림 생성 : FILE *파일포인터;

  • 파일 열기를 fopen() 함수로 처리

  • 파일 입출력을 수행

  • fclose() 함수로 파일 닫기

    🔽
    

    fileio1.c

//fileio1.c
#include <stdio.h>
#include <stdlib.h>

int main()
{
	char ch;
	FILE* fp;	//파일포인터

	//1.스트림 연결
	fp = fopen("file1.txt", "at");		//문자열 상수는  어디인가 존재하는 주소를 가져온다
	if (fp == NULL)
	{
		printf("파일 열기 오류 \n");
		exit(1);
	}

	printf("stdin -> disk \n");			//메모리에 있는걸 디스크에 넣는다
	//2.파일 저장						
	while ((ch = fgetc(stdin)) != EOF)	//EOF : 실행 종료 (ctrl + z)
		fputc(ch, fp);

	//3.스트림 닫기
	fclose(fp);

	 
	//1.스트림 연결
	fp = fopen("file1.txt", "rt");		//문자열 상수는  어디인가 존재하는 주소를 가져온다
	if (fp == NULL)
	{
		printf("파일 열기 오류 \n");
		exit(1);
	}

	printf("stdin -> disk \n");			//메모리에 있는걸 디스크에 넣는다
	//2.파일 저장						
	while ((ch = fgetc(fp)) != EOF)	//EOF : 실행 종료 (ctrl + z)
		fputc(ch, stdout); 

	//3.스트림 닫기
	fclose(fp);

	return 0;

}

fileio1_2.c

#include <stdio.h>
#include <stdlib.h>
int main()
{
	char ch;
	FILE* in, * out;  //파일포인터

	//1.스트림 연결
	in = fopen("fileio1.c", "rt");
	if (in == NULL)
	{
		printf("파일 열기 오류(fileio1.c) \n");
		exit(1);
	}
	out = fopen("fileio1.bak", "wt");
	if (out == NULL)
	{
		printf("파일 열기 오류(fileio1.bak) \n");
		exit(1); 
	} 

	//2.파일복사
	while ((ch = fgetc(in)) != EOF)
		fputc(ch, out);

	//3.스트림 닫기
	fclose(in);
	fclose(out);
	printf("파일복사. \n");
	return 0;
}

fileio1_3.c

//fileio1_3.c

#include <stdio.h>
#include <stdlib.h>

int main()
{
	char ch;
	FILE* fp;	//파일포인터

	//1.스트림 연결
	fp = fopen("file1.txt", "wt");		//문자열 상수는  어디인가 존재하는 주소를 가져온다
	if (fp == NULL)
	{
		printf("파일 열기 오류 \n");
		exit(1);
	}

	printf("stdin -> disk \n");			//메모리에 있는걸 디스크에 넣는다
	//2.파일 저장						
	while ((ch = fgetc(stdin)) != EOF)	//EOF : 실행 종료 (ctrl + z)
		fputc(ch, fp);

	//3.스트림 닫기
	//fclose(fp);
	//닫고 연결하는 과정 생략 => freopen 사용 가능 

	//1.스트림 재연결 
	fp = freopen("file1.txt", "rt", fp);		//문자열 상수는  어디인가 존재하는 주소를 가져온다
	if (fp == NULL)
	{
		printf("파일 열기 오류 \n");
		exit(1);
	}

	printf("stdin -> disk \n");			//메모리에 있는걸 디스크에 넣는다
	//2.파일 저장						
	while ((ch = fgetc(fp)) != EOF)	//EOF : 실행 종료 (ctrl + z)
		fputc(ch, stdout);

	//3.스트림 닫기
	fclose(fp);

	return 0;

}

fileio2.c

//fileio2.c
// 문자열 입출력 
#include <stdio.h>
#include <stdlib.h> // exit 사용 

int main()
{
	char str[20] = "kingdom", tmp[20]; 
	FILE *fp;  // 파일 포인터 변수  

	/*fp = fopen("file2.txt", "wt");		//문자열 상수는  어디인가 존재하는 주소를 가져온다
	if (fp == NULL)
	{
		printf("파일 열기 오류 \n");
		exit(1);
	}

	fputs(str, fp); // int fputs(char*,FILE*);//파일로 문자열을출력한다. 

	fclose(fp); 

	
	*/

	fp = fopen("file2.txt", "rt");		//문자열 상수는  어디인가 존재하는 주소를 가져온다
	if (fp == NULL)
	{
		printf("파일 열기 오류 \n");
		exit(1);
	}

	fgets(tmp, 20, fp); // fgets(str, sizeof(str), fp);
	// 파일포인터(fp)와 연결된 파일로부터 주어진 바이트 수에따라
	// 데이터를 읽어와서 tmp(임시배열)로 주어진 배열에 저장한다.  
	fclose(fp);

	printf("tmp: %s \n", tmp); 

	return 0;
}

// 파일 스트림 생성 , 파일 열기를 fopen() 함수로 처리 => 파일 입출력을 수행 => fclose() 함수로 파일 닫기

fileio2_2.c

//fileio2_2.c

#include <stdio.h>
#include <stdlib.h> 
// 문자열 출력하기 
int main()
{
	char tmp[100]; 
	FILE* fp; //FILE 구조체 

	fp = fopen("C:\\Windows\\system.ini", "rt"); // `//` => 특수문자 해제하여 경로명 지정 
	if (fp == NULL)
	{
		printf("C:\\Windows\\system.ini Open Error."); 
		exit(1); 

	}

	while (1)
	{
		if (fgets(tmp, 80, fp) == NULL) //빈 파일을 읽었을 경우 fgetc는 EOF를 의미하는 -1을 반환하지만, fgets는 널포인터를 반환한다.
			break; 

		printf("%s ", tmp); 

	}

	fclose(fp); 

	return 0; 
}

fileio2_3.c

//fileio2_3.c

#include<stdio.h> 
#include<stdlib.h>

int main()
{
	FILE* fp; 
	char str[5][20] = { "kingdom\n", "king\n", "queen\n", "prince\n", "princess\n" }; 
	char tmp[20]; 
	int i; 

	/*
	fp = fopen("fileio2_3.txt", "wt");
	if (fp == NULL)
	{
		printf("파일 열기 오류 \n"); 
		exit(1); 

	}

	for (i = 0; i < 5; i++)
		fputs(str[i], fp); // str[i]는 행 의미, 행 별 데이터 값 입력됨.  
		*/

	fp = fopen("fileio2_3.txt", "rt");
	if (fp == NULL)
	{
		printf("파일 열기 오류 \n");
		exit(1);

	}

	for (i = 0; i < 5; i++)
	{
		fgets(tmp, sizeof(str[i]), fp); // str[i]는 행 의미, 행 별 데이터 값 입력됨.
		printf("%s", tmp); 
	}
	fclose(fp);

	return 0; 
}


// 3000주소 str[0] =>  `kingdom` `\n`(new line) `\0`
// 3020주소 str[1] =>  `king` `\n(new line)` `\0`
// 3040주소 str[2] =>  `queen` `\n(new line)` `\0`
// 3060주소 str[3] =>  `prince` `\n(new line)` `\0`
// 3080주소 str[4] =>  `princess` `\n(new line)` `\0`

fileio3.c

#include <stdio.h>
#include <stdlib.h>

struct STUDENT {
	char name[20];
	int kor;
	int eng;
	int math;
	float avg;
};

int main() { 
	FILE* fp;
	struct STUDENT stu = { "kim", 50, 90, 62 }, tmp;
	stu.avg = (stu.kor + stu.eng + stu.math) / 3.0;

	//printf("%s, %d, %d, %d, %.2f\n", stu.name, stu.kor, stu.eng, stu.math, stu.avg);
	fp = fopen("file3.txt", "wt");
	if (fp == NULL) {
		printf("Wrong Access.\n");
		exit(1);
	}

	fprintf(fp, "%s %d %d %d %f", stu.name, stu.kor, stu.eng, stu.math, stu.avg);

	fclose(fp);

	fp = fopen("file3.txt", "rt");
	if (fp == NULL) {
		printf("Wrong Access.\n");
		exit(1);
	}

	fscanf(fp, "%s %d %d %d %f", tmp.name, &tmp.kor, &tmp.eng, &tmp.math, &tmp.avg);
	printf("%s %d %d %d %.2f", tmp.name, tmp.kor, tmp.eng, tmp.math, tmp.avg);

	fclose(fp);
}