Какой из этих операторов об объектах верен?

Учитывая тег C ++ [1113689] C ++ C ++ , ответ в значительной степени «возьми свой выбор».

Стандарт C определяет объект как значение (по сути) все, что имеет Адрес, включая все экземпляры нативных / примитивных типов (например, INT). Поскольку C ++ так сильно зависит от C, что определение все еще имеет вес в C ++. По этому определению, по сути, каждая переменная является объектом, и поэтому есть несколько других вещей (например, строковые литералы символов, динамически выделенные блоки памяти).

В SmallTalk (при сравненном противоположном экстремальном) ответ будет ни один из них не является объектом - объект никогда не имеет публичных данных. Его поведение определяется полностью с точки зрения ответов на сообщения.

Вот httpClient 4 Docs , то есть то, что использует Android (4, а не 3, как 1,0-> 2.x). Документы трудно найти (спасибо Apache;)) Потому что httpClient теперь является частью httpComponents (и если вы просто ищете httpClient, вы обычно заканчиваете на веществе 3.x).

Кроме того, если вы выполните любое количество запросов, которые вы не хотите создавать клиента снова и снова. Скорее, как учебники для httpClient Note , создайте клиент один раз и оставьте его вокруг. Оттуда используют ThreadsafecnectionPanager .

Я использую класс помощника, например, что-то вроде httphelper (который все еще является движущейся целью - я планирую переместить это на свой собственный проект Android Util в какой-то момент, и поддерживать двоичные данные, Haven ' T еще не договорился), чтобы помочь с этим. Класс HELPER создает клиент и имеет удобные методы обертки для Get / Post / etc. Где вы используете этот класс из активности , вы должны создать внутреннюю внутреннюю Asynctask (так, что вы не блокируете нить пользовательского интерфейса при выполнении запроса), например:

    private class GetBookDataTask extends AsyncTask<String, Void, Void> {
      private ProgressDialog dialog = new ProgressDialog(BookScanResult.this);

      private String response;
      private HttpHelper httpHelper = new HttpHelper();

      // can use UI thread here
      protected void onPreExecute() {
         dialog.setMessage("Retrieving HTTP data..");
         dialog.show();
      }

      // automatically done on worker thread (separate from UI thread)
      protected Void doInBackground(String... urls) {
         response = httpHelper.performGet(urls[0]);
         // use the response here if need be, parse XML or JSON, etc
         return null;
      }

      // can use UI thread here
      protected void onPostExecute(Void unused) {
         dialog.dismiss();
         if (response != null) {
            // use the response back on the UI thread here
            outputTextView.setText(response);
         }
      }
   }

Существует два обычно используемых определения «объекта» в C ++.

Один является официальным в соответствии со стандартом C ++ и говорит, что все, что имеет хранение, выделенное для него, является объектом. Структура является объектом, int - это объект, Bool является объектом, указатель является объектом, строковый литерал - это объект, и так далее. По этому определению IX , Ia и x - все объекты. Но это, вероятно, не то, что означало ваш учитель. Вы должны быть немного юристом по языку, чтобы использовать это определение, и это не так широко известно среди «средних» пользователей C ++. Это также не очень актуальное определение для кого-то просто изучения языка.

Определение, которое вы , вероятно, , как ожидается, в том, чтобы использовать «объект» в объектно-ориентированном смысле. Здесь (по крайней мере, в семействе языков C ++), как правило, объект должен быть экземпляром класса.

, которые оставляют следующий очевидный вопрос: является ли экземпляром структуры и объекта? Зависит. В C ++ класс и структура по существу одинаковы, поэтому семантически, да, но технически, вы не используете ключевое слово класса , так синтаксически, вероятно, нет.

Короче говоря: это глупо, и плохо сформулированные вопрос, и только вы знаете, что значит ваш учитель или хочет услышать, потому что вы тот, кто посещал классы, а не на нас. Все, что мы можем сделать, это догадаться, в чем он думает, определяет класс.

Можно использовать trie , где длина ключа ограничена. Поскольку поиск в трие с ключом длиной m равен O (m) , если мы ограничиваем длину ключей, то мы ограничиваем m и теперь поиск равен O (1) .

Итак, подумайте о трие, где ключи последовательностей на алфавите {0, 1} (то есть мы думаем, что ключи являются двоичным представлением целых чисел). Если мы ограничим длину ключей 32 буквами, у нас есть структура, которую мы можем считать индексированной 32-битными целыми числами и случайным образом доступной за O (1) время.

Вот реализация в C #:

class TrieArray<T> {
    TrieArrayNode<T> _root;

    public TrieArray(int length) {
        this.Length = length;
        _root = new TrieArrayNode<T>();
        for (int i = 0; i < length; i++) {
            Insert(i);
        }
    }

    TrieArrayNode<T> Insert(int n) {
        return Insert(IntToBinaryString(n));
    }

    TrieArrayNode<T> Insert(string s) {
        TrieArrayNode<T> node = _root;
        foreach (char c in s.ToCharArray()) {
            node = Insert(c, node);
        }
        return _root;
    }

    TrieArrayNode<T> Insert(char c, TrieArrayNode<T> node) {
        if (node.Contains(c)) {
            return node.GetChild(c);
        }
        else {
            TrieArrayNode<T> child = new TrieArray<T>.TrieArrayNode<T>();
            node.Nodes[GetIndex(c)] = child;
            return child;
        }

    }

    internal static int GetIndex(char c) {
        return (int)(c - '0');
    }

    static string IntToBinaryString(int n) {
        return Convert.ToString(n, 2);
    }

    public int Length { get; set; }

    TrieArrayNode<T> Find(int n) {
        return Find(IntToBinaryString(n));
    }

    TrieArrayNode<T> Find(string s) {
        TrieArrayNode<T> node = _root;
        foreach (char c in s.ToCharArray()) {
            node = Find(c, node);
        }
        return node;
    }

    TrieArrayNode<T> Find(char c, TrieArrayNode<T> node) {
        if (node.Contains(c)) {
            return node.GetChild(c);
        }
        else {
            throw new InvalidOperationException();
        }
    }

    public T this[int index] {
        get {
            CheckIndex(index);
            return Find(index).Value;
        }
        set {
            CheckIndex(index);
            Find(index).Value = value;
        }
    }

    void CheckIndex(int index) {
        if (index < 0 || index >= this.Length) {
            throw new ArgumentOutOfRangeException("index");
        }
    }

    class TrieArrayNode<TNested> {
        public TrieArrayNode<TNested>[] Nodes { get; set; }
        public T Value { get; set; }
        public TrieArrayNode() {
            Nodes = new TrieArrayNode<TNested>[2];
        }

        public bool Contains(char c) {
            return Nodes[TrieArray<TNested>.GetIndex(c)] != null;

        }

        public TrieArrayNode<TNested> GetChild(char c) {
            return Nodes[TrieArray<TNested>.GetIndex(c)];
        }
    }
}

Вот пример использования:

class Program {
    static void Main(string[] args) {
        int length = 10;
        TrieArray<int> array = new TrieArray<int>(length);
        for (int i = 0; i < length; i++) {
            array[i] = i * i;
        }
        for (int i = 0; i < length; i++) {
            Console.WriteLine(array[i]);
        }
    }
}

Веб-приложения предотвращены по многим причинам:

1. Их легко защитить
2. Это создает стандартную точку отсчета, к которой может получить доступ каждый:
3. Не блокирует людей, использующих разные платформы.
4. Пользователям проще получить доступ из-за пределов сети (это ставит проблемы безопасности на маршрутизаторы/vpn и т.д.)
5. Меньше технической поддержки (стандартная рабочая платформа)
6. Проще в поддержке (если она снижается, то у вас есть группа критического реагирования, которая может исправить это, а не 1000 машин, которые случайным образом падают)
7. Центральная точка места хранения данных (упрощается резервное копирование и доступ)
8. Может лучше масштабироваться
9. Проще создавать или повторно использовать рамку, чем находить/создавать распределенный набор компонентов для работы с изменяющейся средой (LDAP, различные базы данных, различные резервные копии, синхронизация)
10. Меньше атак (черви, люди, изменяющие клиент и т.д.)
11. Иногда настольные клиенты могут иметь жестко закодированные среды или требуют определенных наборов инструментов, которые заставляют новых пользователей испытывать трудности при настройке
12. Дешевле иметь дело с сервером, чем с 1000-ми клиентами. Можно настроить системы на восстановление и быстрое аварийное восстановление. Да, серверное оборудование стоит дороже, но в долгосрочной перспективе его обслуживание обходится дешевле.

По моему определению, я бы сказал, что объект имеет свойства и методы. Как существительные, так и глаголы.

Вы можете пнуть мяч, вторгнуться в страну, есть, доить или ударить корову. Следовательно, это объекты.

У вас может быть структура данных, которая представляет свойства шара (радиус), страны (население) или коровы (ежедневный выпуск молока в литрах), но эта структура данных не представляет собой объект в моем сознании, пока вы не расскажете ему, как обрабатывать соответствующее поведение.

Я понимаю, что это определение может не работать в 100% случаев, но оно достаточно близко для моих потребностей.

Веб-приложения преобладают по многим причинам:

1. Его легко защитить
2. Это создает стандартную ссылку, которую каждый может получить доступ:
3. не блокирует людей с использованием разных платформ.
4. Легче людям к доступу от вне сети (оно ставит проблемы безопасности на маршрутизаторы / VPN и т. Д.)
5. Менее техническую поддержку (стандартная бегущая платформа)
6. проще для поддержки (если она спущена, то у вас есть Критическая команда реагирования, которая может исправить это, а не 1000-х из машин, которые случайным образом снижаются)
7. центральная точка хранения данных (легче резервного копирования и доступа)
8. могут масштабироваться лучше
9. . Это легче построить или повторно использовать Франки предприятия, чем находить / создать распределенный компонент, установленный для работы с изменяющейся средой (LDAP, разные дб, разные резервные копии, синхронизации)
10. , менее подверженных злоумышленникам (Worms, люди, изменяющие клиента и т. Д.)
11. Иногда может иметь твердые закодированные среды или требуют определенных наборов инструментов, которые создают новых пользователей болей для настройки
12. . Это дешевле, чтобы иметь дело с сервером, а не 1000-х годов клиентов. Вы можете настроить системы, чтобы быть восстановим и иметь быструю неспособность. Да, серверное оборудование стоит больше по фактору, но это стоит меньше, чтобы поддерживать в долгосрочной перспективе.

Технически, объект является экземпляром класса, но истинная полезность объектов заключается в их способности инкапсулировать информацию и помощь в проектировании систем. Это инструмент анализа.

Реальный ответ - это «е. Кто бы ни пишет код, как это должно быть тренируется улучшить их разборчивость ». Хорошо, это была шутка.

Этот вопрос не такой сложный. Но в другом месте я видел программирование тестов, написанные специально комплексным с целью увидеть, если вы сможете решить головоломки. Это совершенно бессмысленно, потому что код, который является то, что комплекс не должен и обычно не существует. Если это сложно читать, это плохо написано код.

Помните, код не написан для компьютеров. Код написан для следующего разработчика после того, как вы читаете и понимаете.

И не пишите код просто так работает. Это не достаточно высокий стандарт. Худший мусор в мире будет работать, но это кошмар, чтобы исправить или обновить.

Объект является объектом типа (будь то стручка или класс).

Как таковые вы можете извлечь адрес объекта. Все объекты занимают хотя бы один байт. Причина этого состоит в том, что вам не нужно добавлять специальный код для обработки объектов нулевого размера, потому что каждый объект в памяти имеет фататичный адрес (сделав все, по меньшей мере, один байт, компилятор, будет автоматически иметь уникальный адрес для каждого объекта).

int main()
{
    struct { int x; } ix; 

    struct A { A() {}; int x; }; 
    A ia;

    ix.x = 5; // Assigned a value.
              // Thus it has state and thus is an object.

    ia.x = 6; // Assigned a value.
}

Итак, они оба объекта.

Слово «объект» представляет собой довольно неоднозначную спецификацию без более одного контекста, но в общем объектах есть , идентичность , поведение , а состояние .

Ни IX , ни IA имеют все три; IX не удается, потому что ему не хватает идентичности или поведения, а Ia не удается, потому что он не имеет поведения. Оба по существу являются просто каплями данных.

Эти вопросы невозможно ответить без дополнительного разъяснения. Вопрос помечен C ++, что означает, что язык предположительно C ++.

В этом случае, если декларации сделаны в области пространства пространства имен, декларация IX недействительна. Незаконно использовать безымянный тип класса (который не имеет связи), чтобы объявить объект с внешним связок. Декларация IX будет работать в локальном объеме

void foo() {
  struct { int x; } ix; // OK, no linkage
}

, это может также работать, если IX был объявлен с внутренней связью в области пространства имен

static struct { int x; } ix; // OK? Internal linkage?

, хотя я лично считаю, что это было предназначено для быть плохо сформированным (Comeau как-то позволяет ему).

Но декларация пространства имен с внешним связью является плохо сформирована

// In namespace scope
struct { int x; } ix; // ERROR

так, если предполагается, что область пространства имен предполагается, и если приведенные выше объявления должны быть предприняты как единый кусок кода, не существует значимых ответов на эти вопросы. Весь код просто недействителен. Это бессмысленно. Это не C ++.

В противном случае, если IX объявлен без связи (локального) или с внутренней связью, то IX является объектом.

как для Ia , это объект независимо от того, где он объявлен, поскольку тип класса назван .

Обратите внимание, что понятие объекта в C ++ не имеет ничего общего с классами. Объект в C ++ - это область хранения (память). Переменная типа INT является объектом в C ++ для одного примера.

добавлено позже: НИЧНОЕ ОЧЕНА ОЧЕНАЛЬНОСТИ IX Декларация является интересной проблемой. Видимо C ++ 98 позволил такие объявления, которые были предложены для объявления в DR # 132 . Однако позже предложение было отклонено (для довольно странной причины), а вещи были оставлены как есть. Тем не менее, Comeau Online отказывается принимать объявление объекта с внешним связью с безымянным типом (внутренняя связь в порядке). Это может быть вполне возможно официальная ошибка в компиляторе Comeau (не так жаловалась на это).

Добавлено даже позже: О, я вижу, что есть даже позже DR # 389 , который, наконец, заблокировал такие объявления, но статус этого доктора по-прежнему CD1.