Форум программистов, компьютерный форум CyberForum.ru

Пораздельная компиляция и повоторное переопределением в gcc - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Ошибка в коде http://www.cyberforum.ru/cpp-beginners/thread857877.html
Прветствую всех! printf("Введите расположение файла (например: C:\\myfile.txt):/n"); char * s; scanf("%s", &s); FILE * doc; doc = fopen(s, "a"); if(doc != NULL) { printf("Введите строку для записи:/n");
C++ надо написать две проги на с+= нужна 1, 2 лаба, 3вариант http://www.cyberforum.ru/cpp-beginners/thread857873.html
C++ виход из проги клавишей Esc
Как на С++ зделать чтоб из программы виходило при нажатии Esc,что прописывать ?
если в массиве положительные элементы или отрицательные элементы будут соседями C++
очень нужна помощь! помогите пожалуйста! если в массиве a положительные элементы или отрицательные элементы будут соседями то вывести их на экран.(то есть если -5 -2 2 2 -6 7, вывести -5 -2 2 2) а иначе вывести отрицательные элементы по их порядку! заранее спасибо))))))) очень буду благодарна))))))
C++ Арифметика длинных чисел с плавающей запятой http://www.cyberforum.ru/cpp-beginners/thread857833.html
Добрый вечер, есть ли у кого исходники основных операций * / + - больших чисел с плавающей запятой? Например дано: char * a = "1142354332443324.2352463412312112312523445657658678"; char * b = "123124.1243242"; требуется выполнять основные арифметические операции, приведенные выше. Спасибо
C++ Считывание строк из файла Здравствуйте, подскажите, пожалуйста, как организовать чтение строк из файла при помощи ifstream\ofstream таким образом, чтобы считывалось все содержимое файла, а не только символы до первого пробела? подробнее

Показать сообщение отдельно
xtorne21st
интересующийся
303 / 274 / 19
Регистрация: 25.09.2010
Сообщений: 1,056

Пораздельная компиляция и повоторное переопределением в gcc - C++

06.05.2013, 22:55. Просмотров 341. Ответов 4
Метки (Все метки)

Доброго времени суток. Пытаюсь разобрать пример с учебника. Теоритически вроде всё делаю правильно...
Bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
ilyuha21st@coldshoot:~/Projects/calc$ g++ calc.cpp -c -o calc.o
ilyuha21st@coldshoot:~/Projects/calc$ g++ main.cpp -c -o main.o
ilyuha21st@coldshoot:~/Projects/calc$ g++ main.o calc.o -o prog
calc.o:(.bss+0x0): multiple definition of `Driver::no_of_errors'
main.o:(.bss+0x0): first defined here
calc.o:(.bss+0x8): multiple definition of `Lexer::string_value'
main.o:(.bss+0x8): first defined here
calc.o:(.bss+0x10): multiple definition of `Lexer::number_value'
main.o:(.bss+0x10): first defined here
calc.o:(.data+0x0): multiple definition of `Lexer::curr_token'
main.o:(.data+0x0): first defined here
calc.o:(.bss+0x20): multiple definition of `Driver::table'
main.o:(.bss+0x20): first defined here
calc.o:(.bss+0x50): multiple definition of `Driver::input'
main.o:(.bss+0x50): first defined here
collect2: error: ld returned 1 exit status
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
// calc.h
#ifndef _CALCULATOR_HEADER_
#define _CALCULATOR_HEADER_
 
#include <string>
#include <iostream>
#include <map>
 
namespace Driver
{
    int no_of_errors = 0;
}
 
namespace Error
{
    struct Zero_divide
    {
        Zero_divide() { Driver::no_of_errors++; }
    };
 
    struct Syntax_error
    {
        Syntax_error(const char* p) { err = p; Driver::no_of_errors++; }
 
        const char* err;
        const char* what()
        {
            return err;
        }
    };
}
 
namespace Lexer
{
    enum Token_value 
    {
        NAME,       NUMBER,     END,       
        PLUS='+',   MINUS='-',  MUL='*',    DIV='/',
        PRINT=';',  ASSIGN='=', LP='(',     RP=')'      
    };
 
    std::string string_value;
    double number_value;
    Token_value curr_token = PRINT;
 
    Token_value get_token();
}
 
namespace Parser
{
    double expr(bool);
    double term(bool);
    double prim(bool);
}
 
namespace Driver
{
    std::map<std::string, double> table;
    std::istream* input;
    void skip();
 
    using Parser::expr;
}
 
#endif
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
//calc.cpp
#include "calc.h"
#include <cctype>
 
Lexer::Token_value Lexer::get_token()
{
    char ch;
    
    do
    {
        if (!Driver::input->get(ch))
        {
            return curr_token = END;
        }
    } while (ch != '\n' && isspace(ch));
 
    switch (ch)
    {
        case 0:
            return curr_token = END;
        case ';':
        case '\n':
            return curr_token = PRINT;
        case '+':
        case '-':
        case '/':
        case '*':
        case '=':
        case '(':
        case ')':
            return curr_token = Token_value(ch);
        case '0':   case '1':   case '2':   case '3':   case '4':
        case '5':   case '6':   case '7':   case '8':   case '9':
        case '.':
            Driver::input->putback(ch);
            *Driver::input >> number_value;
            return curr_token = NUMBER;
        default:
            if (isalpha(ch))
            {
                string_value = ch;
                while (Driver::input->get(ch) && isalnum(ch))
                {
                    string_value.push_back(ch);
                }
                return curr_token = NAME;
            }
            throw Error::Syntax_error("bad token");
    }
}
 
double Parser::expr(bool get)
{
    double left = term(get);
 
    for ( ; ; )
    {
        switch (Lexer::curr_token)
        {
            case Lexer::PLUS:
                left += term(true);
                break;
            case Lexer::MINUS:
                left -= term(true);
                break;
            default:
                return left;
        }
    }
}
 
double Parser::term(bool get)
{
    double left = prim(get);
    
    for ( ; ; )
    {
        switch (Lexer::curr_token)
        {
            case Lexer::MUL:
                left *= prim(true);
                break;
            case Lexer::DIV:
                if (double v = prim(true))
                {
                    left /= v;
                }
                throw Error::Zero_divide();
            default:
                break;
        }
    }
}
 
double Parser::prim(bool get)
{
    if (get)
    {
        Lexer::get_token();
    }
 
    switch (Lexer::curr_token)
    {
        case Lexer::NUMBER:
            {
                double v = Lexer::number_value;
                Lexer::get_token();
                return v;
            }
        case Lexer::NAME:
            {
                double& v = Driver::table[Lexer::string_value];
                if (Lexer::get_token() == Lexer::ASSIGN)
                {
                    v = expr(true);
                }
                return v;
            }
        case Lexer::MINUS:
            return prim(true);
        case Lexer::LP:
            {
                double e = expr(true);
                if (Lexer::curr_token != Lexer::ASSIGN)
                {
                    throw Error::Syntax_error("')' expected");
                }
                Lexer::get_token();
                return e;
            }
        default:
            throw Error::Syntax_error("pimary expected");
    }
}
 
 
void Driver::skip()
{
    char ch;
 
    while (*input)
    {
        input->get(ch);
 
        switch (ch)
        {
            case '\n':
            case ';':
                break;
        }
    }
}
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
 // main.cpp
#include "calc.h"
#include <iostream>
#include <sstream>
 
int main(int argc, const char* argv[])
{
    switch (argc)
    {
        case 1:
            Driver::input = &std::cin;
            break;
        case 2:
            Driver::input = new std::stringstream(argv[1]);
            break;
        default:
            std::cerr << "to many arguments" << std::endl;
            return 1;
    }
 
    while (*Driver::input)
    {
        try
        {
            Lexer::get_token();
            if (Lexer::curr_token == Lexer::END)
            {
                break;
            }
            if (Lexer::curr_token == Lexer::PRINT)
            {
                continue;
            }
            std::cout << Driver::expr(false) << std::endl;
        }
        catch (Error::Zero_divide)
        {
            std::cerr << "divide by zero" << std::endl;
            Driver::skip();
        }
        catch (Error::Syntax_error e)
        {
            std::cerr << "error: " << e.what() << std::endl;
            Driver::skip();
        }
    }
 
    if (Driver::input != &std::cin)
    {
        delete Driver::input;
    }
 
    return Driver::no_of_errors;
}
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru