Что такое полиморфизм времени компиляции и почему он только относится к функциям?
Знайте Ваш свойства оси ! Существуют все виды вещей, которые можно установить для тонкой настройки свойств графического изображения значения по умолчанию, чтобы сделать то, что Вы хотите:
set(gca,'fontsize',8,'linestyleorder','-','linewidth',0.3,'xtick',1:2:9);
(как пример, устанавливает fontsize на 8 ПБ, стили линии всех новых строк ко всем быть твердым и их ширина 0.3 ПБ, и xtick указывает, чтобы быть [1 3 5 7 9])
Строка и , свойства рисунка также полезны, но я использую свойства оси больше всего.
5 ответов
Давным-давно, когда «полиморфизм времени компиляции» означал перегрузку функции. Это применимо только к функциям, потому что они все, что вы можете перегрузить.
В текущем C ++ шаблоны меняют это. Нил Баттерворт уже привел один пример. Другой использует специализацию шаблона. Например:
#include <iostream>
#include <string>
template <class T>
struct my_template {
T foo;
my_template() : foo(T()) {}
};
template <>
struct my_template<int> {
enum { foo = 42 };
};
int main() {
my_template<int> x;
my_template<long> y;
my_template<std::string> z;
std::cout << x.foo << "\n";
std::cout << y.foo << "\n";
std::cout << "\"" << z.foo << "\"";
return 0;
}
Это должно дать 42 , 0 и "" (пустая строка) - мы получаем структуру, которая действует по-другому. для каждого типа.
Здесь у нас есть «полиморфизм времени компиляции» классов вместо функций. Я полагаю, если вы хотите оспорить эту точку зрения, вы могли бы утверждать, что это, по крайней мере частично, является результатом конструктора (функции) по крайней мере в одном случае, но специализированная версия my_template этого не делает. Даже у есть конструктор.
Изменить: Относительно того, почему это полиморфизм. Я не зря заключил «полиморфизм времени компиляции» в кавычки - он несколько отличается от обычного полиморфизма. Тем не менее, мы получаем эффект, аналогичный тому, что мы ожидаем от функций перегрузки:
int value(int x) { return 0; }
long value(long x) { return 42; }
std::cout << value(1);
std::cout << value(1L);
Перегрузка функций и специализация дают аналогичные эффекты. Я согласен с тем, что остается открытым вопрос, применим ли «полиморфизм» к тому или иному, но я думаю, что он одинаково хорошо применим как к одному, так и к другому.
int value(int x) { return 0; }
long value(long x) { return 42; }
std::cout << value(1);
std::cout << value(1L);
Перегрузка функций и специализация дают аналогичные эффекты. Я согласен с тем, что остается открытым вопрос, применим ли «полиморфизм» к тому или иному, но я думаю, что он одинаково хорошо применим как к одному, так и к другому.
int value(int x) { return 0; }
long value(long x) { return 42; }
std::cout << value(1);
std::cout << value(1L);
Перегрузка функций и специализация дают аналогичные эффекты. Я согласен с тем, что остается открытым вопрос о том, применим ли «полиморфизм» к любому из них, но я думаю, что он одинаково хорошо применим как к одному, так и к другому.
Под полиморфизмом времени компиляции обычно подразумевается тот факт, что у вас может быть несколько функций с одинаковым именем, и компилятор выберет во время компиляции какой из них использовать в зависимости от аргументов:
void foo(int x);
void foo(float y);
//Somewhere else
int x = 3;
foo(x); //Will call first function
float y = 2;
foo(y); //Will call second function
Функция foo называется перегруженной. Различные типы создания экземпляров шаблона можно также назвать полиморфизмом времени компиляции.
Полиморфизм времени компиляции - это термин, относящийся к программированию шаблонов C ++. Например, во время компиляции вы определяете фактический тип std :: vector по тому, что он содержит:
std::vector <int> vi;
std::vector <std::string> vs;
Я не уверен, почему вы думаете, что он ограничен функциями.
То, что применимо только к функциям, - это вывод параметров шаблона. Если у меня есть шаблон функции:
template <typename T>
void foo(T &t);
Тогда я могу сделать int a = 0; foo (a); , и это будет эквивалентно int a = 0; foo . Компилятор работает, что я имею в виду foo . По крайней мере, получается, что он должен использовать foo - если это не то, что я имел в виду, тогда мне не повезло, и я мог бы написать foo или что-то еще.
Однако, если у меня есть шаблон класса:
template <typename T>
struct Foo {
T &t;
Foo(T &t) : t(t) {}
T &getT() { return t; }
};
Тогда я не могу сделать int a = 0; Foo (а) .getT (); . Я должен указать Foo . Компилятору не разрешено работать, я имею в виду Foo .
Таким образом, вы можете сказать, что шаблоны классов "
Полиморфизм времени компиляции применяется к функциям и перегрузкам операторов.
Прочтите http://cpp-tutorial.cpp4u.com/OOP_polymorphism.html