Когда использовать "::" и когда использовать ".".

Ответ 1

Разница - это первый оператор разрешения области, а второй - синтаксис доступа к членству.

Итак, :: (разрешение области) можно использовать для доступа к чему-то еще в пространстве имен, например вложенном классе, или для доступа к статической функции. Оператор периода . будет просто получать доступ к любому видимому элементу экземпляра класса, в котором вы его используете.

Некоторые примеры:

class A {
    public:

        class B { };

        static void foo() {}
        void bar() {}
};

//Create instance of nested class B.
A::B myB; 

//Call normal function on instance of A.
A a;
a.bar();

//Call the static function on the class (rather than on an instance of the class). 
A::foo(); 

Обратите внимание, что статическая функция или элемент данных - это тот, который принадлежит самому классу, независимо от того, создали ли вы какие-либо экземпляры этого класса. Таким образом, если бы у меня была статическая переменная в моем классе и была разбита тысяча экземпляров этого класса, осталось еще 1 экземпляр этой статической переменной. Было бы 1000 экземпляров любого другого участника, который не был бы статичным, хотя один на экземпляр класса.

Еще один интересный вариант, когда вы приходите к нему:) Вы также увидите:

//Create a pointer to a dynamically allocated A.
A* a = new A();

//Invoke/call bar through the pointer.
a->bar();

//Free the memory!!! 
delete a;

Динамическая память может быть немного более запутанной, если вы еще не узнали ее, поэтому я не буду вдаваться в подробности. Просто хотел, чтобы вы знали, что вы можете получить доступ к элементам с помощью { :: или . или ->}:)

Ответ 2

в С++ :: - оператор разрешения области. Он используется для различения пространств имен и статических методов, в основном в любом случае, когда у вас нет объекта. Где . используется для доступа к объектам внутри объекта.

С# использует оператор . для обоих из них.

namespace Foo
{
    public class Bar
    {          
        public void Method()
        {
        }

        public static void Instance()
        {
        }

    }
}

в С# вы должны написать код следующим образом:

var blah = new Foo.Bar();
blah.Method();

но эквивалентный код на С++ выглядел бы следующим образом:

Foo::Bar blah;
blah.Method();

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

Foo::Bar::Instance();

Где снова код С# будет использовать только оператор точки

Foo.Bar.Instance();

Ответ 3

:: предназначен для пространств имен и статического доступа членов. Вместо этого С# использует оператор-точка для пространств имен.

. предназначен для доступа к нестационарным элементам.

Не исчерпывающее разграничение, но это соответствующие биты, которые могут смутить вас в свете С# и Java.

Для получения дополнительной информации см.

IBM - Оператор разрешения масштаба

IBM-Dot Operator

Ответ 4

:: - это оператор разрешения области видимости, поэтому, когда вы разрешаете область действия, такую ​​как пространство имен или класс, вы используете это. Для доступа к члену у вас есть .

Ответ 5

Оператор области :: может быть трудно понять, если вы не понимаете пространства имен или классы. Пространство имен подобно контейнеру для имен различных вещей в вашем коде. Они обычно используются для устранения неоднозначности имен, которые являются общими для библиотек. Скажем, что оба пространства имен std и example имеют функцию foobar(). Поэтому компилятор знает, какую функцию вы хотите использовать, вы добавляете его как std::foobar() или example::foobar().

Оператор :: также может использоваться, когда вы сообщаете компилятору, который хотите определить функцию, объявленную в классе или структуре. Например:

class foobar()
{
  public:
  void hello();
  int number; //assume there is a constructor that sets this to 5
}

void foobar::hello()
{
  cout << "Hello, world!" << endl;
}

Оператор . используется, когда вы хотите использовать член класса или структуры. Например:

foobar foo;
foo.hello();
cout << foo.number << endl;

Предполагая, что класс завершен путем написания конструктора, ожидается, что результат этого будет:

Hello, world!
5

Ответ 6

Вы используете оператор . тот же, что и в java, при обращении к членам класса после его создания в программе. :: используется в ряде случаев:

Когда вы определяете метод в .h/.cpp определенного класса, напишите

class::methodName()

либо для прототипирования, либо для его реализации.

Кроме того, если вы явно не укажете, какое пространство имен вы используете, вам придется использовать его

std::cout << "This is the output";

вместо использования cout << "This is the output;

Может быть, есть еще, но я не помню прямо сейчас, мой С++ немного ржавый.

Ответ 7

В С++ :: предназначен для определения области. Это может означать область видимости пространства имен или.

Eg.

int x;

namespace N {
    int x;

    struct foo {
        static double x;
        double y;    
    };
    struct bar: public foo {
        double y;
    };
}

int main()
{
    int x; // we have a local, hiding the global name
    x = ::x; // explicitly identify the x in global scope
    x += N::x; // explicitly identify the x in namespace N

    N::foo::x = x; // set the static member of foo to our local integer
    N::foo f;
    f.y = f.x; // the static member is implicitly scoped by the object
    f.y += N::foo::x; // or explicitly scoped

    N::bar b;
    assert(b.x == N::foo::x); // this static member is inherited
    b.y = b.x; // we get N::bar::y by default
    b.N::foo::y = b.y; // explicitly request the hidden inherited one
}

// we need to define the storage for that static somewhere too ...
int N::foo::x (0.0);