reference

问题 Can the C++ compiler assume a 'const bool &' value will not change? For example, imagine that I have a class: class test { public: test(const bool &state) : _test(state) { } void doSomething() { if (_test) { doMore(); } } void doMore(); private: const bool &_test; }; And I use it as follows: void example() { bool myState = true; test myTest(myState); while (someTest()) { myTest.doSomething(); myState = anotherTest(); } } Is it allowed by the standard for the compiler to assume _test's value

问题 Can the C++ compiler assume a 'const bool &' value will not change? For example, imagine that I have a class: class test { public: test(const bool &state) : _test(state) { } void doSomething() { if (_test) { doMore(); } } void doMore(); private: const bool &_test; }; And I use it as follows: void example() { bool myState = true; test myTest(myState); while (someTest()) { myTest.doSomething(); myState = anotherTest(); } } Is it allowed by the standard for the compiler to assume _test's value

问题 I have a bidirectional relationship @Entity @Table(name = "facility") public class Facility implements Serializable { @Id @GeneratedValue private Long id; @OneToMany(mappedBy = "facility") private Set<Amenity> amenities; } @Entity @Table(name = "amenity") public class Amenity implements Serializable { @Id @GeneratedValue private Long id; @ManyToOne private Facility facility; } This all works fine and I can see the table is created correctly. I can add data fine through a rest endpoint and but

问题 Suppose I have a class class Foo { : : } I have another function void getf( Foo &f) { : : std::cout<<sizeof f<<std::endl; } After I process the data and assign a lot of data to f (vector included in Foo members), I need the size of f object However, as what I did above, I always get 16, which is the size of a reference here. Did I do anything wrong? How to do that? Thanks! 回答1: sizeof returns the size of a type. Often time, as in the case of a Vector , the size of the type does not

问题 If I use a const reference to another member, is it possible that this reference gets invalidated? class Class { public: const int &x{y}; private: int y; }; For example when I use instances of this class in a vector which increases its capacity after a push_back . According to the standard all iterators and references are invalidated if a vector has to increase its capacity. Is the reference still valid after that? 回答1: This is currently not safe, as when you copy an instance of Class , x

问题 If I do something like this: byte[] buffer = new byte[1024]; Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); IPEndPoint remote = new IPEndPoint(IPAddress.Parse("12.34.56.78"), 1337); sock.ReceiveFrom(buffer, ref remote); Will the ReceiveFrom method only receive packets from the endpoint that is being passed? The documentation states the following: With connectionless protocols, ReceiveFrom will read the first enqueued datagram received into the local

问题 #include <vector> struct A { int a[100]; }; void foo (const A& a) { std::vector<A> vA; vA.push_back(std::move(a)); // how does move really happen? } int main () { A a; foo(a); } The above code compiles fine. Now everywhere it's written that move avoids copying. Following are my queries: Does the move really work when one deals with a lvalue [non]- const reference? Even with "rvalue reference", how is the copy avoided when the object is inserted into a standard container like above? e.g. void

问题 I have a C++ memory management doubt, that's (obviously) related to references and pointers. Suppose I have a class Class with a method my_method : OtherClass& Class::my_method( ... ) { OtherClass* other_object = new OtherClass( ... ); return *other_object; } Meanwhile in a nearby piece of code: { Class m( ... ); OtherClass n; n = m.my_method( ... ); } So, I know that there's a general rule about pointers (~ "anything new-ed, must be delete-d") to avoid memory leaks. But basicly I'm taking a

问题 I have a C++ memory management doubt, that's (obviously) related to references and pointers. Suppose I have a class Class with a method my_method : OtherClass& Class::my_method( ... ) { OtherClass* other_object = new OtherClass( ... ); return *other_object; } Meanwhile in a nearby piece of code: { Class m( ... ); OtherClass n; n = m.my_method( ... ); } So, I know that there's a general rule about pointers (~ "anything new-ed, must be delete-d") to avoid memory leaks. But basicly I'm taking a

问题 Consider the following C++ program: #include <iostream> template<typename T> class A { public: explicit A(T& x) : x_(x){} const T& get() { return x_; } private: T x_; }; int main() { int x = 42; A<int&>(x).get() = 43; // compiles fine, even though get() looks like it returns a const ref std::cout << x << '\n'; } The program compiles OK and outputs 43. This suggests that the seemingly const reference returned by get() is in fact a non-const reference, because it allows to modifies the value it