Lời khuyên về không gian tên trong C ++

Question 1

Tôi chỉ đang tự học không gian tên C ++ (đến từ nền tảng C #) và tôi thực sự bắt đầu nghĩ rằng ngay cả với tất cả những thứ mà C ++ làm tốt hơn hầu hết các ngôn ngữ khác, không gian tên lồng nhau không phải là một trong số đó!

Tôi có đúng khi nghĩ rằng để khai báo một số không gian tên lồng nhau, tôi phải làm như sau:

namespace tier1
{
    namespace tier2
    {
        namespace tier3
        {
            /* then start your normal code nesting */
        }
    }
}

Như trái ngược với:

namespace tier1::tier2::tier3
{
}

à la C #?

Điều này thậm chí còn trở nên mất trí nhớ hơn khi tôi cần chuyển tiếp khai báo:

namespace tier1
{
    namespace tier2
    {
        namespace forward_declared_namespace
        {
            myType myVar; // forward declare
        }
        namespace tier3
        {
            /* then start your normal code nesting */
            class myClass
            {
                forward_declared_namespace::myType myMember;
            }
        }
    }
}

Lưu ý rằng một hệ thống điển hình mà tôi phát triển bao gồm:

MyCompany::MySolution::MyProject::System::[PossibleSections]::Type

Đây có phải là lý do tại sao bạn không có xu hướng sử dụng nhiều không gian tên trong các ví dụ C ++? Hay thường chỉ có các vùng tên đơn (không lồng nhau)?

CẬP NHẬT

Đối với bất kỳ ai quan tâm, đây là cách tôi giải quyết vấn đề này.

Question 2

Không gian tên C ++ không nhằm mục đích trở thành một cơ chế thiết kế - chúng ở đó chỉ đơn giản là để ngăn chặn xung đột tên. Bạn thực sự không muốn hoặc không cần sử dụng các không gian tên lồng nhau trong 99,99% trường hợp.

Một ví dụ điển hình về việc sử dụng đúng không gian tên trong C ++ là Thư viện chuẩn C ++. Mọi thứ trong thư viện khá lớn này được đặt trong một không gian tên duy nhất được gọi là std - không cần cố gắng hoặc không cần phải chia thư viện thành (ví dụ) không gian tên phụ I / O, không gian tên con toán học, không gian tên phụ vùng chứa Vân vân.

Công cụ cơ bản để tạo mô hình trong C ++ là lớp (và ở một mức độ nào đó là khuôn mẫu), không phải không gian tên. Nếu bạn cảm thấy cần phải lồng nhau, bạn nên cân nhắc sử dụng các lớp lồng nhau, có những ưu điểm sau so với không gian tên:

họ có phương pháp
họ có thể kiểm soát quyền truy cập
chúng không thể được mở lại

Sau khi xem xét những điều này, nếu bạn vẫn muốn sử dụng các không gian tên lồng nhau bằng mọi cách - không có gì sai về mặt kỹ thuật khi sử dụng chúng theo cách này.

Question 3

Không gian tên C ++ là một cải tiến lớn so với cung cấp trước đó (tức là không có không gian tên nào cả). Không gian tên C # đã mở rộng khái niệm và chạy cùng với nó. Tôi khuyên bạn nên giữ không gian tên của bạn trong một cấu trúc phẳng đơn giản.

CHỈNH SỬA Bạn có khuyên rằng do những điểm ngắn mà tôi đã nêu ở đây không?

Đơn giản là "Có". Không gian tên C ++ không được thiết kế để giúp bạn phân vùng logic & thư viện theo cách chúng làm trong C #.

Mục đích của không gian tên C ++ là để ngăn chặn vấn đề trong thế giới thực mà các nhà phát triển C gặp phải, nơi họ gặp phải xung đột tên khi sử dụng hai lib của bên thứ ba xuất (các) tên hàm giống nhau. Các nhà phát triển C có nhiều cách giải quyết khác nhau cho nó, nhưng nó có thể là một vấn đề nghiêm trọng.

Ý tưởng là STL vv có std::không gian tên, các lib do "XYZ Corp" cung cấp sẽ có một xyz::không gian tên, bạn làm việc cho "ABC corp" sẽ đặt tất cả nội dung của bạn vào một abc::không gian tên duy nhất .

Question 4

những gì tôi làm khi khai báo chuyển tiếp trông như thế này:

 namespace abc { namespace sub { namespace subsub { class MyClass; }}}

Các khai báo chuyển tiếp của tôi được thu gọn thành một dòng. Khả năng đọc của khai báo chuyển tiếp bị hy sinh để đổi lại khả năng đọc của phần còn lại của mã. Và đối với các định nghĩa, tôi cũng không sử dụng thụt lề:

 namespace abc {
 namespace sub {
 namespace subsub {
 
 class MyClass 
 {
    public:
       MyClass();

       void normalIntendationsHere() const;
 };

 }
 }
 }

Sử dụng phong cách này đòi hỏi một chút kỷ luật khi bắt đầu, nhưng đó là sự thỏa hiệp tốt nhất đối với tôi.

Kể từ C ++ 17, bạn có thể khai báo không gian tên với cú pháp do tác giả của câu hỏi đề xuất.

namespace A::B::C { ... }

định nghĩa không gian tên lồng nhau: namespace A::B::C { ... }tương đương với namespace A { namespace B { namespace C { ... } } }.

https://en.cppreference.com/w/cpp/language/namespace

Question 5

Ít nhất là một trợ giúp nhỏ, trong một số trường hợp, bạn có thể làm điều này:

namespace foo = A::B::C::D;

Và sau đó tham chiếu A :: B :: C :: D như foo. Nhưng chỉ trong một số trường hợp.

Question 6

Bạn có thể bỏ qua thụt lề. Tôi thường viết

namespace myLib { namespace details {

/* source code */

} } /* myLib::details */

Mã nguồn C ++ cuối cùng được biên dịch thành nhị phân, không giống như C # / Java vẫn ở trong hệ nhị phân. Do đó, không gian tên chỉ cung cấp một giải pháp tốt cho xung đột đặt tên biến. Nó không dành cho phân cấp lớp.

Tôi thường giữ một hoặc hai mức không gian tên trong mã.

Question 7

Trước hết, bạn có thể tránh thụt đầu dòng không gian tên, bởi vì không có lý do gì cho điều đó.

Sử dụng không gian tên trong các ví dụ sẽ không hiển thị sức mạnh không gian tên. Và quyền lực của họ đối với tôi là phân chia các khu vực Miền với nhau. Phân chia các lớp tiện ích từ các lớp kinh doanh.

Chỉ cần không kết hợp các cấu trúc phân cấp không gian tên khác nhau trong một tệp .h. Không gian tên là một loại bình luận bổ sung cho giao diện khai báo hàm của bạn. Nhìn vào không gian tên và tên lớp sẽ giải thích rất nhiều thứ.

namespace product
{
namespace DAO
{

class Entity
{
};

Question 8

Bạn đang sử dụng chúng quá mức (và bạn sẽ không nhận được gì).

Question 9

Tôi nhận thấy rằng bạn có thể bắt chước không gian tên c # như thế này;

namespace ABC_Maths{
    class POINT2{};
    class Complex{};
}

namespace ABC_Maths_Conversion{
    ABC_MATHS::Complex ComplexFromPOINT2(ABC_MATHS::POINT2)
    {return new ABC_MATHS::Complex();}

    ABC_MATHS::POINT4 POINT2FromComplex(ABC_MATHS::COMPLEX)
    {return new ABC_MATHS::POINT2();}
}

namespace ABC
{
}

Nhưng mã có vẻ không được gọn gàng cho lắm. và tôi mong đợi sẽ sử dụng lâu dài

Tốt hơn là lồng càng nhiều chức năng vào các lớp như

namespace ABC{
    class Maths{
        public:
        class POINT2{};
        class Complex:POINT2{};
        class Conversion{
            public:
            static Maths.Complex ComplexFromPOINT2(MATHS.POINT2 p)
            {return new MATHS.Complex();}

            static MATHS.POINT2 POINT2FromComplex(MATHS.COMPLEX p)
            {return new ABC::MATHS.POINT2();}// Can reference via the namespace if needed
} /*end ABC namespace*/

Và điều đó vẫn còn hơi dài. nhưng không cảm thấy một chút OO.

Và nghe cách nó có vẻ được thực hiện tốt nhất

namespace ABC
{
    class POINT2{};
    class Complex:POINT2{};
    Complex ComplexFromPOINT2(POINT2 p){return new Complex();}
    POINT2 POINT2FromComplex(Complex){return new POINT2();}
}

nghe cách sử dụng sẽ trông như thế nào

int main()
{
    ABC_Maths::Complex p = ABC_Maths_Conversion::ComplexFromPOINT2(new ABC_MATHS::POINT2());

    // or THE CLASS WAY

    ABC.Maths.Complex p = ABC.Maths.Conversion.ComplexFromPOINT2(new ABC.Maths.POINT2());

    // or if in/using the ABC namespace

    Maths.Complex p = Maths.Conversion.ComplexFromPOINT2(new Maths.POINT2());

    // and in the final case

    ABC::Complex p = ABC::ComplexFromPOINT2(new ABC::POINT2());
}

Thật thú vị khi tìm hiểu lý do tại sao tôi không bao giờ sử dụng không gian tên c ++ như tôi làm với c #. Nó sẽ quá dài và sẽ không bao giờ hoạt động giống như không gian tên c #.

cách sử dụng tốt nhất cho không gian tên trong c ++ là ngăn không cho hàm super cout của tôi (nó hoạt động mỗi khi nó được gọi) khỏi bị lẫn với hàm std :: cout (ít ấn tượng hơn).

Chỉ vì c # và c ++ có không gian tên, không có nghĩa là không gian tên có nghĩa giống nhau. chúng khác nhau nhưng giống nhau. Ý tưởng cho không gian tên c # hẳn đến từ không gian tên c ++. ai đó chắc hẳn đã thấy những gì một thứ tương tự nhưng khác biệt có thể làm, và không còn đủ trí tưởng tượng để đặt cho nó cái tên ban đầu như "ClassPath", điều này sẽ có ý nghĩa hơn khi nó là một đường dẫn đến các lớp thay vì cung cấp đặt tên cho không gian trong đó mỗi không gian có thể có các tên giống nhau

tôi hi vọng điêu nay se giup được ai đo

Tôi quên nói rằng tất cả những cách này đều hợp lệ và việc sử dụng vừa phải hai cách đầu tiên có thể được kết hợp với cách thứ ba để tạo ra một thư viện có ý nghĩa (không phải ví dụ tuyệt vời)

_INT::POINT2{}

và

_DOUBLE::POINT2{}

vì vậy bạn có thể thay đổi mức độ chính xác bằng cách sử dụng

#define PREC _DOUBLE 
// or #define PREC _INT

và sau đó tạo một phiên bản của PREC :: POINT2 cho POINT2 chính xác gấp đôi

Đó không phải là điều dễ dàng thực hiện với không gian tên c # hoặc java

rõ ràng đó chỉ là một ví dụ. Hãy suy nghĩ về cách sử dụng đọc.

Question 10

Đôi khi tôi khai báo không gian tên sâu dưới dạng một vài macro trong tiêu đề riêng biệt

không gian tên.h

#define NAMESPACE_TIER1_TIER2_TIER3 \
    namespace tier1 { \
    namespace tier2 { \
    namespace tier3 {

#define END_NAMESPACE_TIER1_TIER2_TIER3 }}}

Để sử dụng nó ở một nơi khác:

anotherfile.h

#include "./namespace.h"

NAMESPACE_TIER1_TIER2_TIER3;

/* Code here */

END_NAMESPACE_TIER1_TIER2_TIER3;

Dấu chấm phẩy thừa sau macro là để tránh thụt lề thừa.