Форум программистов, компьютерный форум, киберфорум
Наши страницы

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 98, средняя оценка - 4.88
Sylar9
-20 / 55 / 2
Регистрация: 04.09.2011
Сообщений: 1,942
Записей в блоге: 1
#1

А ваше реально самому выучить язык программирования - C++

26.10.2011, 08:26. Просмотров 12552. Ответов 23
Метки нет (Все метки)

Вот хотел спросить а ваше реально самому выучить язык программирования??? и кто из вас уже его выучил
0
Лучшие ответы (1)
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
26.10.2011, 08:26
Здравствуйте! Я подобрал для вас темы с ответами на вопрос А ваше реально самому выучить язык программирования (C++):

Реально выучить С++ - C++
А ваше реально самому выучить С++ без преподаватель, и кому это удавалось что читали ?

Изучение С++. Реально ли самому? - C++
Учился полтора месяца самостоятельно по книжке и через форумы с++. Посмотрев написанный мною код, ясен пень, знающие люди сказали что я...

выучить язык с++ - C++
Друзья подскажите какие лутче читать книги что бы выучить с++ как вы учили ?? подскажите .

Хочу выучить с++ для программирования игр - C++
Добрый день. Дело в том что хочу выучить с++ для программирования игр. В интернетах полно информации и видео уроков по этой теме, но...

Какую литературу читать если реально самому реализовать данный проект - C++
Здраствуйте уважаемые форумчани незнал куда написать тему решил сюда) реально ли самому написать 3д онлине игру если да порекомендуйте...

Как называется движение программирования или теория программы считывающая др. язык программирования - C++
Не знал, как по другому задать вопрос, и также назвать тему, но буду краток: Допустим я хочу создать программу, которая будет...

23
ForEveR
26.10.2011, 15:22     А ваше реально самому выучить язык программирования
  #16

Не по теме:

taras atavin, А чем шарп то плох?

0
fasked
Эксперт С++
4948 / 2528 / 180
Регистрация: 07.10.2009
Сообщений: 4,311
Записей в блоге: 1
26.10.2011, 15:30 #17
Я самоучка.
0
taras atavin
26.10.2011, 15:31
  #18

Не по теме:

Может и не плох, но достаточно бегло посмотреть по нему ответы только на этом форуме, чтоб насчитать сложностей больше, чем их вообще есть суммарно в 5-ти других языках.

0
silent_1991
26.10.2011, 15:33
  #19

Не по теме:

ForEveR, там структуры с классами - разные вещи

2
taras atavin
26.10.2011, 15:44
  #20

Не по теме:

Цитата Сообщение от silent_1991 Посмотреть сообщение
там структуры с классами - разные вещи
На чистых сях тоже, так как там вообще нет классов. И на паскале запись и класс - не одно и тоже (запись соответсвует сёвой структуре). Зато
Метода расширения позволяют "добавлять" методы в существующие типы без создания нового производного типа, перекомпиляции или иного изменения исходного типа.
Чтоб учить, как делать методы расширения, надо понять, зачем они нужны. Ну и зачем? Есть же и агрегация, и наследование. И структуры агрегируются в классах в любом случае, даже если сами классами не являются. Зачем понадобилась ешё одна сущность? Дальше
Методы расширения являются особым видом статического метода, но они вызываются, как если бы они были методами экземпляра
А это как понять? Есть статические члены, а есть не статические. Одно другому концептуально противоположно.
добавляющие функции запроса в существующие типы
Ещё бы понимать, что такое "функция запроса", что она делает и зачем. Мало? И это только по ссылке в одном ответе.

0
ForEveR
В астрале
Эксперт С++
7983 / 4742 / 321
Регистрация: 24.06.2010
Сообщений: 10,545
Завершенные тесты: 3
26.10.2011, 16:03 #21
taras atavin,

Не по теме:

Тарас. Шаблоны в 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
namespace ext
{
    public static class Pal
    {
        public static IEnumerable<T> GetPalindroms<T>(this IEnumerable<T> array)
        {
            List<T> lst = new List<T>();
            foreach(var val in array)
            {
                if (Convert.ToString(val) == 
                    new string(Convert.ToString(val).Reverse().ToArray()))
                {
                    lst.Add(val);
                }
            }
            return lst.AsEnumerable();
        }
    }
}
namespace first
{
    using ext;
    class App
    {
        public static void Main(string[] args)
        {
            int[] array = {111, 212, 1234, 1221, 12345, 12321};
            Console.WriteLine(string.Join(", ", array.GetPalindroms()));
        }
    }
}

0
taras atavin
26.10.2011, 16:06
  #22

Не по теме:

Цитата Сообщение от ForEveR Посмотреть сообщение
Шаблоны в C++
Ты специально выбрал самое простое? То есть не для новичка, конечно, но когда до них дойдёшь, то они оказываются проще всего на свете.

0
ForEveR
26.10.2011, 16:09
  #23

Не по теме:

taras atavin, О да. Самое простое. Особенно когда шаблон на шаблоне. Тот же буст к примеру. Ладно. Заканчиваем оффтопить.

Ну и напоследок...

Вот такие вот простые шаблоны. Разберешься?


Typelist.h
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
////////////////////////////////////////////////////////////////////////////////
// The Loki Library
// Copyright (c) 2001 by Andrei Alexandrescu
// This code accompanies the book:
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
//     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
// Permission to use, copy, modify, distribute and sell this software for any 
//     purpose is hereby granted without fee, provided that the above copyright 
//     notice appear in all copies and that both that copyright notice and this 
//     permission notice appear in supporting documentation.
// The author or Addison-Welsey Longman make no representations about the 
//     suitability of this software for any purpose. It is provided "as is" 
//     without express or implied warranty.
////////////////////////////////////////////////////////////////////////////////
#ifndef LOKI_TYPELIST_INC_
#define LOKI_TYPELIST_INC_
 
// $Id: Typelist.h 749 2006-10-17 19:49:26Z syntheticpp $
 
 
#include "NullType.h"
#include "TypeManip.h"
#include "TypelistMacros.h"
 
 
namespace Loki
{
////////////////////////////////////////////////////////////////////////////////
// class template Typelist
// The building block of typelists of any length
// Use it through the LOKI_TYPELIST_NN macros
// Defines nested types:
//     Head (first element, a non-typelist type by convention)
//     Tail (second element, can be another typelist)
////////////////////////////////////////////////////////////////////////////////
 
    template <class T, class U>
    struct Typelist
    {
       typedef T Head;
       typedef U Tail;
    };
 
// Typelist utility algorithms
 
    namespace TL
    {
 
////////////////////////////////////////////////////////////////////////////////
// class template MakeTypelist
// Takes a number of arguments equal to its numeric suffix
// The arguments are type names.
// MakeTypelist<T1, T2, ...>::Result
// returns a typelist that is of T1, T2, ...
////////////////////////////////////////////////////////////////////////////////
 
        template
        <
            typename T1  = NullType, typename T2  = NullType, typename T3  = NullType,
            typename T4  = NullType, typename T5  = NullType, typename T6  = NullType,
            typename T7  = NullType, typename T8  = NullType, typename T9  = NullType,
            typename T10 = NullType, typename T11 = NullType, typename T12 = NullType,
            typename T13 = NullType, typename T14 = NullType, typename T15 = NullType,
            typename T16 = NullType, typename T17 = NullType, typename T18 = NullType
        > 
        struct MakeTypelist
        {
        private:
            typedef typename MakeTypelist
            <
                T2 , T3 , T4 , 
                T5 , T6 , T7 , 
                T8 , T9 , T10, 
                T11, T12, T13,
                T14, T15, T16, 
                T17, T18
            >
            ::Result TailResult;
 
        public:
            typedef Typelist<T1, TailResult> Result;
        };
 
        template<>
        struct MakeTypelist<>
        {
            typedef NullType Result;
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template Length
// Computes the length of a typelist
// Invocation (TList is a typelist):
// Length<TList>::value
// returns a compile-time constant containing the length of TList, not counting
//     the end terminator (which by convention is NullType)
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList> struct Length;
        template <> struct Length<NullType>
        {
            enum { value = 0 };
        };
        
        template <class T, class U>
        struct Length< Typelist<T, U> >
        {
            enum { value = 1 + Length<U>::value };
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template TypeAt
// Finds the type at a given index in a typelist
// Invocation (TList is a typelist and index is a compile-time integral 
//     constant):
// TypeAt<TList, index>::Result
// returns the type in position 'index' in TList
// If you pass an out-of-bounds index, the result is a compile-time error
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList, unsigned int index> struct TypeAt;
        
        template <class Head, class Tail>
        struct TypeAt<Typelist<Head, Tail>, 0>
        {
            typedef Head Result;
        };
 
        template <class Head, class Tail, unsigned int i>
        struct TypeAt<Typelist<Head, Tail>, i>
        {
            typedef typename TypeAt<Tail, i - 1>::Result Result;
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template TypeAtNonStrict
// Finds the type at a given index in a typelist
// Invocations (TList is a typelist and index is a compile-time integral 
//     constant):
// a) TypeAt<TList, index>::Result
// returns the type in position 'index' in TList, or NullType if index is 
//     out-of-bounds
// b) TypeAt<TList, index, D>::Result
// returns the type in position 'index' in TList, or D if index is out-of-bounds
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList, unsigned int index,
            typename DefaultType = NullType>
        struct TypeAtNonStrict
        {
            typedef DefaultType Result;
        };
        
        template <class Head, class Tail, typename DefaultType>
        struct TypeAtNonStrict<Typelist<Head, Tail>, 0, DefaultType>
        {
            typedef Head Result;
        };
        
        template <class Head, class Tail, unsigned int i, typename DefaultType>
        struct TypeAtNonStrict<Typelist<Head, Tail>, i, DefaultType>
        {
            typedef typename 
                TypeAtNonStrict<Tail, i - 1, DefaultType>::Result Result;
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template IndexOf
// Finds the index of a type in a typelist
// Invocation (TList is a typelist and T is a type):
// IndexOf<TList, T>::value
// returns the position of T in TList, or NullType if T is not found in TList
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList, class T> struct IndexOf;
        
        template <class T>
        struct IndexOf<NullType, T>
        {
            enum { value = -1 };
        };
        
        template <class T, class Tail>
        struct IndexOf<Typelist<T, Tail>, T>
        {
            enum { value = 0 };
        };
        
        template <class Head, class Tail, class T>
        struct IndexOf<Typelist<Head, Tail>, T>
        {
        private:
            enum { temp = IndexOf<Tail, T>::value };
        public:
            enum { value = (temp == -1 ? -1 : 1 + temp) };
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template Append
// Appends a type or a typelist to another
// Invocation (TList is a typelist and T is either a type or a typelist):
// Append<TList, T>::Result
// returns a typelist that is TList followed by T and NullType-terminated
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList, class T> struct Append;
        
        template <> struct Append<NullType, NullType>
        {
            typedef NullType Result;
        };
        
        template <class T> struct Append<NullType, T>
        {
            typedef Typelist<T,NullType> Result;
        };
 
        template <class Head, class Tail>
        struct Append<NullType, Typelist<Head, Tail> >
        {
            typedef Typelist<Head, Tail> Result;
        };
        
        template <class Head, class Tail, class T>
        struct Append<Typelist<Head, Tail>, T>
        {
            typedef Typelist<Head, 
                    typename Append<Tail, T>::Result>
                Result;
        };
        
////////////////////////////////////////////////////////////////////////////////
// class template Erase
// Erases the first occurence, if any, of a type in a typelist
// Invocation (TList is a typelist and T is a type):
// Erase<TList, T>::Result
// returns a typelist that is TList without the first occurence of T
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList, class T> struct Erase;
        
        template <class T>                         // Specialization 1
        struct Erase<NullType, T>
        {
            typedef NullType Result;
        };
 
        template <class T, class Tail>             // Specialization 2
        struct Erase<Typelist<T, Tail>, T>
        {
            typedef Tail Result;
        };
 
        template <class Head, class Tail, class T> // Specialization 3
        struct Erase<Typelist<Head, Tail>, T>
        {
            typedef Typelist<Head, 
                    typename Erase<Tail, T>::Result>
                Result;
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template EraseAll
// Erases all first occurences, if any, of a type in a typelist
// Invocation (TList is a typelist and T is a type):
// EraseAll<TList, T>::Result
// returns a typelist that is TList without any occurence of T
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList, class T> struct EraseAll;
        template <class T>
        struct EraseAll<NullType, T>
        {
            typedef NullType Result;
        };
        template <class T, class Tail>
        struct EraseAll<Typelist<T, Tail>, T>
        {
            // Go all the way down the list removing the type
            typedef typename EraseAll<Tail, T>::Result Result;
        };
        template <class Head, class Tail, class T>
        struct EraseAll<Typelist<Head, Tail>, T>
        {
            // Go all the way down the list removing the type
            typedef Typelist<Head, 
                    typename EraseAll<Tail, T>::Result>
                Result;
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template NoDuplicates
// Removes all duplicate types in a typelist
// Invocation (TList is a typelist):
// NoDuplicates<TList, T>::Result
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList> struct NoDuplicates;
        
        template <> struct NoDuplicates<NullType>
        {
            typedef NullType Result;
        };
 
        template <class Head, class Tail>
        struct NoDuplicates< Typelist<Head, Tail> >
        {
        private:
            typedef typename NoDuplicates<Tail>::Result L1;
            typedef typename Erase<L1, Head>::Result L2;
        public:
            typedef Typelist<Head, L2> Result;
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template Replace
// Replaces the first occurence of a type in a typelist, with another type
// Invocation (TList is a typelist, T, U are types):
// Replace<TList, T, U>::Result
// returns a typelist in which the first occurence of T is replaced with U
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList, class T, class U> struct Replace;
        
        template <class T, class U>
        struct Replace<NullType, T, U>
        {
            typedef NullType Result;
        };
 
        template <class T, class Tail, class U>
        struct Replace<Typelist<T, Tail>, T, U>
        {
            typedef Typelist<U, Tail> Result;
        };
 
        template <class Head, class Tail, class T, class U>
        struct Replace<Typelist<Head, Tail>, T, U>
        {
            typedef Typelist<Head,
                    typename Replace<Tail, T, U>::Result>
                Result;
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template ReplaceAll
// Replaces all occurences of a type in a typelist, with another type
// Invocation (TList is a typelist, T, U are types):
// Replace<TList, T, U>::Result
// returns a typelist in which all occurences of T is replaced with U
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList, class T, class U> struct ReplaceAll;
        
        template <class T, class U>
        struct ReplaceAll<NullType, T, U>
        {
            typedef NullType Result;
        };
        
        template <class T, class Tail, class U>
        struct ReplaceAll<Typelist<T, Tail>, T, U>
        {
            typedef Typelist<U, typename ReplaceAll<Tail, T, U>::Result> Result;
        };
        
        template <class Head, class Tail, class T, class U>
        struct ReplaceAll<Typelist<Head, Tail>, T, U>
        {
            typedef Typelist<Head,
                    typename ReplaceAll<Tail, T, U>::Result>
                Result;
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template Reverse
// Reverses a typelist
// Invocation (TList is a typelist):
// Reverse<TList>::Result
// returns a typelist that is TList reversed
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList> struct Reverse;
        
        template <>
        struct Reverse<NullType>
        {
            typedef NullType Result;
        };
        
        template <class Head, class Tail>
        struct Reverse< Typelist<Head, Tail> >
        {
            typedef typename Append<
                typename Reverse<Tail>::Result, Head>::Result Result;
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template MostDerived
// Finds the type in a typelist that is the most derived from a given type
// Invocation (TList is a typelist, T is a type):
// MostDerived<TList, T>::Result
// returns the type in TList that's the most derived from T
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList, class T> struct MostDerived;
        
        template <class T>
        struct MostDerived<NullType, T>
        {
            typedef T Result;
        };
        
        template <class Head, class Tail, class T>
        struct MostDerived<Typelist<Head, Tail>, T>
        {
        private:
            typedef typename MostDerived<Tail, T>::Result Candidate;
        public:
            typedef typename Select<
                SuperSubclass<Candidate,Head>::value,
                    Head, Candidate>::Result Result;
        };
 
////////////////////////////////////////////////////////////////////////////////
// class template DerivedToFront
// Arranges the types in a typelist so that the most derived types appear first
// Invocation (TList is a typelist):
// DerivedToFront<TList>::Result
// returns the reordered TList 
////////////////////////////////////////////////////////////////////////////////
 
        template <class TList> struct DerivedToFront;
        
        template <>
        struct DerivedToFront<NullType>
        {
            typedef NullType Result;
        };
        
        template <class Head, class Tail>
        struct DerivedToFront< Typelist<Head, Tail> >
        {
        private:
            typedef typename MostDerived<Tail, Head>::Result
                TheMostDerived;
            typedef typename Replace<Tail,
                TheMostDerived, Head>::Result Temp;
            typedef typename DerivedToFront<Temp>::Result L;
        public:
            typedef Typelist<TheMostDerived, L> Result;
        };
        
    }   // namespace TL
}   // namespace Loki
 
 
#endif // end file guardian



0
Revol'veR
23 / 23 / 2
Регистрация: 05.11.2010
Сообщений: 134
26.10.2011, 16:28 #24
Чтобы научиться языку, надо ещё параллельно изучать алгоритмы.
0
26.10.2011, 16:28
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
26.10.2011, 16:28
Привет! Вот еще темы с ответами:

Язык программирования С++ - C++
Доброго времени суток, Уважаемые Форумчане! Я учусь в БГУИР на инженер-программиста (Минск). И возник вопрос - Хочу стать экспертом в...

скачать язык программирования С - C++
где я могу скачать язык программирования С

Язык программирования компилятора в C++ - C++
Добрый день! Разглядывая новые возможности С++11 (С++14) и читая статьи, посвященные шаблонам, мне пришла в голову мысль - по сути...

Основы программирования язык С - C++
Здравствуйте, у меня такая проблема, необходимо писать программы в turbo c запускаю через code:blocks и пишу код, но при попытке...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
24
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru