Post

반응형
간단한 링크드 리스트를 만들어보았다.

서로 참조하는 링크드 리스트는 좀 어려운듯ㅠ_ㅠ

원형 큐도 공부해야 하고@_@ 공부할 것 많다 ㅋㅋ!

자료구조랑 DB랑 C, C++ 기초 확실하게 공부해야 한다.

혹시 오류 있으면 지적해주세요!


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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#include <iostream>
using namespace std;
 
class Node
{
public:
    int nValue;
    Node* pNextNode;
};
 
class NodeList
{
    Node* m_pHead;
    
public:
    NodeList() : m_pHead(NULL)
    {
        
    }
    ~NodeList()
    {
        Node* pTemp = m_pHead;
        
        while(pTemp)
        {
            Node* pTempNode = pTemp;
            pTemp = pTemp->pNextNode;
        
            delete pTempNode;
            pTempNode = NULL;
        }
    }
 
    void Add(int Value)
    {
        if(NULL == m_pHead)
        {
            Node* pNewNode = new Node();
            pNewNode->nValue = Value;
            pNewNode->pNextNode = NULL;
            m_pHead = pNewNode;
        }
        else
        {
            Node* pTemp = m_pHead;
            
            while(true)
            {
                if(NULL == pTemp->pNextNode)
                    break;
                
                pTemp = pTemp->pNextNode;
            }
            
            Node* pNewNode = new Node();
            pNewNode->nValue = Value;
            pNewNode->pNextNode = NULL;
            pTemp->pNextNode = pNewNode;
        }
    }
 
    Node* Find(int Value)
    {
        Node* pTemp = m_pHead;
        
        while(pTemp)
        {
            if(pTemp->nValue == Value)
                return pTemp;
 
            pTemp = pTemp->pNextNode;
        }
 
        return NULL;
    }
 
    bool Delete(int Value)
    {
        Node* pTemp = m_pHead;
        Node* pTemp2 = NULL;
        bool bCheck = false;
 
        while(pTemp)
        {
            if(pTemp->nValue == Value)
            {
                bCheck = true;
                break;
            }
            pTemp2 = pTemp;
            pTemp = pTemp->pNextNode;
        }
 
        if(bCheck)
        {
            if(pTemp == m_pHead)
            {
                m_pHead = pTemp->pNextNode;
                delete pTemp;
                pTemp = NULL;    
            }
            else
            {
                pTemp2->pNextNode = pTemp->pNextNode;
                delete pTemp;
                pTemp = NULL;            
            }
        }
 
        return bCheck;
    }
 
    void Print()
    {
        Node* pTemp = m_pHead;
        
        while(NULL != pTemp)
        {
            printf("%d", pTemp->nValue);
            pTemp = pTemp->pNextNode;
        }
 
        printf("\n");
    }
};
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
class Node
{
public:
    int value;
    Node* m_pNextNode;
};
 
class LinkedList
{
    Node* m_pHead;
public:
    LinkedList()
    {
        m_pHead = NULL;
    }
 
    ~LinkedList()
    {
        Node* pNode = m_pHead;
        while(pNode)
        {
            Node* pTempNode = pNode->m_pNextNode;
            pNode = pNode->m_pNextNode;
            delete pTempNode;
            pTempNode = NULL;            
        }
    }
    
    void Add(int value)
    {
        Node* pNewNode = new Node();
        pNewNode->value = value;
        pNewNode->m_pNextNode = NULL;
            
        if(NULL == m_pHead)
        {
            m_pHead = pNewNode;
        }
        else
        {
            Node* pTemp = m_pHead;
            while(pTemp)
            {
                if(NULL == pTemp->m_pNextNode)
                {
                    pTemp->m_pNextNode = pNewNode;
                    break;
                }
                pTemp = pTemp->m_pNextNode;
            }
        }
    }
 
    Node* Find(int value)
    {
        Node* pNode = m_pHead;
        bool bResult = false;
        
        while(!pNode)
        {
            if(pNode->value == value)
                return pNode;
        }
        return NULL;
    }
 
    void Delete(int value)
    {
        Node* pTemp = m_pHead;
        Node* pTemp2 = NULL;
        bool bCheck = false;
 
        while(NULL != pTemp)
        {
            if(value == pTemp->value)
            {
                bCheck = true;
                break;
            }
 
            pTemp2 = pTemp;
            pTemp = pTemp->m_pNextNode;
        }
 
        if(bCheck)
        {
            if(m_pHead == pTemp)
            {
                m_pHead = pTemp->m_pNextNode;
                delete pTemp;
                pTemp = NULL;                
            }
            else
            {
                Node* pNode = pTemp->m_pNextNode;
                pTemp2->m_pNextNode = pNode;
                delete pTemp;
                pTemp = NULL;
            }
        }        
    }
 
    void Print()
    {
        Node* pNode = m_pHead;
 
        while(pNode)
        {
            cout<< pNode->value <<endl;
            pNode = pNode->m_pNextNode;
        }
        cout<<endl;
    }
};
 
void main()
{
    LinkedList linkedList;
    linkedList.Add(1);
    linkedList.Add(2);
    linkedList.Add(3);
    linkedList.Print();
    linkedList.Delete(1);
    linkedList.Delete(2);
    linkedList.Print();
    linkedList.Add(4);
    linkedList.Print();
    getchar();
}
cs


반응형

Post

반응형
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
44
45
46
47
48
49
50
#include <iostream>
using namespace std;
 
 
int main()
{
    // 문자열 뒤집기
    char str[20= "abcdefg2";
    int strCount = strlen(str);
    int middleStrCount = strCount * 0.5f;
 
    int i = 0;
    int j = strCount - 1;
    for(int k = 0; k < middleStrCount; ++k)
    {
        char temp = str[i];
        str[i] = str[j];
        str[j] = temp;
        ++i;
        --j;
    }
    
    cout<< str <<endl;
 
    // 한글 뒤집기
    char str2[25= "가나다라마바사";
    cout<< str2 <<endl;
    int strCount2 = strlen(str2);
    int middleStrCount2 = strCount2 * 0.5f * 0.5f;        // 한글 2바이트, 절반
 
    int i2 = 0;
    int j2 = strCount2 - 1;
    for(int k = 0; k < middleStrCount2; ++k)
    {
        char temp[2= {str2[i2], str2[i2+1]};
        str2[i2] = str2[j2-1];
        str2[i2+1= str2[j2];
        str2[j2-1= temp[0];
        str2[j2] = temp[1];
    
        i2+=2;
        j2-=2;
    }
    cout<< str2 <<endl;
 
    getchar();
}
 
 
 
cs


너무 오랜만에 글을 올린다ㅠ_ㅠ

블로그 완전 방치모드였다;;;



C++ 문자열 뒤집기 예제 소스

문득 한글 뒤집기는 어떻게 하지?!

궁금해서 만들어보았다.


반응형

Post

반응형



사용할 수 있는 적절한 기본 생성자가 없습니다... 이 에러때문에 일주일간 고생했다.

AttackState클래스를 기본생성자로 만들어서 사용하려고 하는데 위 에러가 뜸;;;

보다시피 기본생성자도 있는데 적절한 생성자가 없다니?!

다행히 지신의 도움으로 해결되었다.

이유는 내가 전방선언을 정확히 이해못한 것 때문이었다...

Monster클래스와 AttackState는 서로 참조하는 관계인데,

전방선언은 그냥 이 클래스가 있다 정도만 알려주기 때문에 전방 클래스를 사용하고 바로 사용할 수 없다.

헤더 파일에서 AttackState를 생성하지말고 cpp에서 생성해야된다.



반응형

'이전게시판 > C, C++' 카테고리의 다른 글

C++ 다중상속 문제점?  (0) 2016.04.04
C++ 데드락(DeadLock)  (0) 2016.04.04
2의 보수 만드는 법  (0) 2016.04.01
구조체 패딩이란?  (0) 2016.03.31
C++ 스택(Stack) 예제  (0) 2016.03.20
C++ 간단한 원형 큐  (0) 2016.03.20
c++ 링크드리스트 만들기  (0) 2016.03.19
C++ 문자열 뒤집기, 한글 뒤집기  (0) 2016.03.18

Post

반응형

c# 3.0 이후부터 무명 메소드, 람다식, linq 등.. 편리한 기능이 많이 추가되었다.

평소에 쓰던대로 쓰지~하면서 귀찮아서 미루고 있었는데 이번기회에 정리해본다.



1) C#의 var이란?

var은 임시변수로 어떤 타입이라도 될 수 있습니다.(null은 안됨)

그리고 선언과 동시에 초기화 해줘야 합니다.

만약 처음에 string값을 넣었으면 string값만 담을 수 있습니다.



2) 무명 메소드

무명메소드는 임시로 만드는 함수입니다.

함수속에 함수로 만들어지기 때문에 무명 메소드를 참조하기 위해

delegate와 함께 사용됩니다.



3) 람다식

무명 메소드를 간단하게 나타낸 식을 말합니다.

아래와 같이 무명 메소드를 나타냈다면

Func1 = delegate(String s)

{

Console.WriteLine("{0} \n", s);

};


람다식으로 이렇게 바꿀 수 있습니다.


Func1 = (s) => Console.WriteLine("{0} \n", s);


4) LINQ

데이터베이스 처럼 WHERE, FROM 같은 질의를 C# 내 사용할 수 있습니다.

만약 10 아래의 숫자를 찾을 때 linq가 없다면 전체 Link를 한바퀴 돌면서

매번 10보다 아래인지 확인할 것입니다.

여기에 다른 조건이 2,3개 추가되면 if문이 추가 되어 복잡해집니다.

하지만 linq는 WHERE 조건만 넣으면 찾아줘서 매우 편리합니다.


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
44
45
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace Main3
{
    class Student
    {
        public string name  { get; set; }
        public int grade    { get; set; }           // 학년
        public int gradeClass { get; set; }         // 등급
    }
 
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
 
            Student[] StudentList =
            {
                new Student() {name = "김학생", grade = 1, gradeClass = 10 },
                new Student() {name = "박학생", grade = 1, gradeClass = 52 },
                new Student() {name = "천학생", grade = 2, gradeClass = 116 },
                new Student() {name = "강학생", grade = 2, gradeClass = 3 },
                new Student() {name = "최학생", grade = 2, gradeClass = 73 },
                new Student() {name = "이학생", grade = 3, gradeClass = 25 },
            };
 
            var student = from st in StudentList
                              where st.grade == 1 && st.gradeClass < 20
                              orderby st.name ascending
                              select st;
 
            foreach (var st in student)
                Console.WriteLine("이름 : {0} 학년: {1} 등급 : {2} \n", st.name, st.grade, st.gradeClass);
        }
    }
}
 
cs


반응형

'이전게시판 > C#' 카테고리의 다른 글

프로퍼티 스택오버플로우..  (0) 2018.08.10
StreamReader 한글깨짐 오류  (0) 2018.08.10
배열보다 리스트가 좋은 이유  (0) 2017.04.30
▲ top