Что является различием между X = X ++; по сравнению с X ++;?
Я только что написал класс util, включая методы тестирования, вы можете проверить ~
IteratePackageUtil.java:
package eric.j2se.reflect;
import java.util.Set;
import org.reflections.Reflections;
import org.reflections.scanners.ResourcesScanner;
import org.reflections.scanners.SubTypesScanner;
import org.reflections.util.ClasspathHelper;
import org.reflections.util.ConfigurationBuilder;
import org.reflections.util.FilterBuilder;
/**
* an util to iterate class in a package,
*
* @author eric
* @date Dec 10, 2013 12:36:46 AM
*/
public class IteratePackageUtil {
/**
* <p>
* Get set of all class in a specified package recursively. this only support lib
* </p>
* <p>
* class of sub package will be included, inner class will be included,
* </p>
* <p>
* could load class that use the same classloader of current class, can't load system packages,
* </p>
*
* @param pkg
* path of a package
* @return
*/
public static Set<Class<? extends Object>> getClazzSet(String pkg) {
// prepare reflection, include direct subclass of Object.class
Reflections reflections = new Reflections(new ConfigurationBuilder().setScanners(new SubTypesScanner(false), new ResourcesScanner())
.setUrls(ClasspathHelper.forClassLoader(ClasspathHelper.classLoaders(new ClassLoader[0])))
.filterInputsBy(new FilterBuilder().includePackage(pkg)));
return reflections.getSubTypesOf(Object.class);
}
public static void test() {
String pkg = "org.apache.tomcat.util";
Set<Class<? extends Object>> clazzSet = getClazzSet(pkg);
for (Class<? extends Object> clazz : clazzSet) {
System.out.println(clazz.getName());
}
}
public static void main(String[] args) {
test();
}
}
13 ответов
X ++ увеличит значение, но тогда возвратит его старое значение.
Так в этом случае:
static void Main(string[] args)
{
int x = 10;
x = x++;
Console.WriteLine(x);
}
Вы имеете X в 11 просто на мгновение, тогда это возвращается к 10, потому что 10 возвращаемое значение (x ++).
Вы могли вместо этого сделать это для того же результата:
static int plusplus(ref int x)
{
int xOld = x;
x++;
return xOld;
}
static void Main(string[] args)
{
int x = 10;
x = plusplus(x);
Console.WriteLine(x);
}
также стоит упомянуть, что у Вас был бы свой ожидаемый результат 11, если Вы сделаете:
static void Main(string[] args)
{
int x = 10;
x = ++x;
Console.WriteLine(x);
}
Простое объяснение:
x ++ - это постфиксное приращение.
Что делает компилятор:
a) Присваивает значение x переменной x б) Увеличьте временное значение x (я думаю, его можно даже оптимизировать) c) Отбросьте временное значение x
. Если вы хотите, чтобы код возвращал 11 с присвоением, напишите:
x = ++ x;
Помещение инкрементного оператора после переменной означает, что инкремент и присвоение происходят после , выражение оценено... так исходный оператор x = x ++; переводит в 1. Оцените x и сохраните значение в tyransient памяти... Теперь выполните код, требовавшийся ++ оператор.... (шаги 2 & 3) 2. Инкрементное значение x (в переходной памяти) 3. Присвойте Увеличенное значение месту хранения x... Теперь, продолжите отдых выполнения строки, налево, существует = знак... 5. Поэтому присвойте значение, сохраненное на Шаге 1 (неувеличенное значение) к выражению на левом из = знак..., который является x
Как автономный оператор, x++; и инкремент и присвоение. Кажется, что существуют некоторые беспорядки относительно того, что происходит когда. Если мы будем иметь
int x = 10;
int y = (x++) + 2;
, то Мы доберемся x = 11 и y = 12. Текущее значение x присвоено, и тогда , инкремент и переназначение x происходят. <забастовка> Так, при использовании той же переменной,
int x = 10; // Create a variable x, and assign an initial value of 10.
x = x++; // First, assign the current value of x to x. (x = x)
// Second, increment x by one. (x++ - first part)
// Third, assign the new value of x to x. (x++ - second part)
Любой способ, которым Вы смотрите на него, новое значение x, равняется 11.
я был абсолютно неправ в том.
Попытайтесь звонить ++ x и посмотрите, работает ли это.
Результат присвоения
x = x++;
не определен в C и C++ , и я предположил бы то же с C# также.
Так, фактическая последовательность операций, которая происходит, зависят от того, как компилятор решает к реализациям его, нет никакой гарантии, произойдут ли присвоение или инкремент сначала. (это четко определено в C#, как Jon Skeet указал в комментариях. Хотя я теперь чувствую, что этот ответ имеет намного меньше ценности теперь, я остаюсь на этом посту, восстановленном после удаления для вопроса OP и его ответа в комментариях.)
Однако в этом случае, это появляется последовательность операций, которая происходит:
- старое значение (10) из x сохраняется
- , x увеличен для ++ часть
- , которая старое значение теперь присвоено x для присвоения
Таким образом, хотя инкремент происходит, это настигает присвоение со старым значением, таким образом сохраняя x в 10.
HTH
Можно думать о нем как это:
int x = 10;
X контейнер и содержит значение, 10.
x = x++;
Это может быть сломано к:
1) increment the value contained in x
now x contains 11
2) return the value that was contained in x before it was incremented
that is 10
3) assign that value to x
now, x contains 10
Теперь, распечатайте значение, содержавшееся в x
Console.WriteLine(x);
И, неудивительно, это распечатывает 10.
x++;
делает следующее:
int returnValue = x;
x = x+1;
return returnValue;
, Как Вы видите, исходное значение сохраняется, x увеличен, и затем исходное значение возвращается.
то, Что это заканчивает тем, что делало, сохраняет значение 10 где-нибудь, установка x, равная 11, и затем возвращается 10, который заставляет x быть задержанным к 10. Обратите внимание, что x действительно на самом деле становится 11 для нескольких циклов (принимающий компиляторную оптимизацию).
Это не отвечает на вопрос непосредственно, но почему в мире кто-либо использовал бы
x = x++;
?
Это полностью побеждает цель post-increment/pre-increment оператора.
x = 10
x = ++x
x закончил бы тем, что равнялся 11.
В присвоении x = x++ Вы первый извлекаете старое значение x для использования в оценке правого выражения стороны, в этом случае 'x'; тогда, Вы увеличиваете x 1. Наконец, Вы присваиваете результаты вычисления выражения (10) к x через оператор присваивания.
, Возможно, эквивалентный код ясно дал бы понять затруднительное положение:
var tmp = x;
x++;
x = tmp;
Это - эквивалент Вашего x = x++ код в C#.
Поведение x ++ состоит в том, чтобы увеличить x, но возвратить значение прежде инкремент. Его названные сообщение увеличивают поэтому.
Так x = x ++; просто помещенный будет
1. возвратите значение , тогда
2. увеличьте x , тогда
3. присвойтесь исходное значение (возвратился на шаге 1) x к x .
По определению, x ++, возвращает значение x и затем увеличивает x.
http://blogs.msdn.com/lucabol/archive/2004/08/31/223580.aspx