Извинения за вопрос, который, как я предполагаю, чрезвычайно прост.
У меня возникли проблемы с поиском онлайн-разницы между оператором:: и. в С++
У меня есть несколько лет опыта работы с С# и Java, и я знаком с концепцией использования. оператор для доступа к члену.
Может ли кто-нибудь объяснить, когда они будут использоваться и какая разница?
Спасибо за ваше время
Разница - это первый оператор разрешения области, а второй - синтаксис доступа к членству.
Итак, :: (разрешение области) можно использовать для доступа к чему-то еще в пространстве имен, например вложенном классе, или для доступа к статической функции. Оператор периода . будет просто получать доступ к любому видимому элементу экземпляра класса, в котором вы его используете.
Некоторые примеры:
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;
Динамическая память может быть немного более запутанной, если вы еще не узнали ее, поэтому я не буду вдаваться в подробности. Просто хотел, чтобы вы знали, что вы можете получить доступ к элементам с помощью { :: или . или ->}:)
в С++ :: - оператор разрешения области. Он используется для различения пространств имен и статических методов, в основном в любом случае, когда у вас нет объекта. Где . используется для доступа к объектам внутри объекта.
С# использует оператор . для обоих из них.
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();
:: предназначен для пространств имен и статического доступа членов. Вместо этого С# использует оператор-точка для пространств имен.
. предназначен для доступа к нестационарным элементам.
Не исчерпывающее разграничение, но это соответствующие биты, которые могут смутить вас в свете С# и Java.
Для получения дополнительной информации см.
:: - это оператор разрешения области видимости, поэтому, когда вы разрешаете область действия, такую как пространство имен или класс, вы используете это. Для доступа к члену у вас есть .
Оператор области :: может быть трудно понять, если вы не понимаете пространства имен или классы. Пространство имен подобно контейнеру для имен различных вещей в вашем коде. Они обычно используются для устранения неоднозначности имен, которые являются общими для библиотек. Скажем, что оба пространства имен 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
Вы используете оператор . тот же, что и в java, при обращении к членам класса после его создания в программе.
:: используется в ряде случаев:
Когда вы определяете метод в .h/.cpp определенного класса, напишите
class::methodName()
либо для прототипирования, либо для его реализации.
Кроме того, если вы явно не укажете, какое пространство имен вы используете, вам придется использовать его
std::cout << "This is the output";
вместо использования cout << "This is the output;
Может быть, есть еще, но я не помню прямо сейчас, мой С++ немного ржавый.
В С++ :: предназначен для определения области. Это может означать область видимости пространства имен или.
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);