without pointer C++ string how to expression string is nullptr?

So you can use std::optional to express this:

std::optional<std::string> null_string = std::nullopt; // this is the "null" state

if (optional_string) { /// Can be used like a null or bool type

std::optional<std::string> empty_string = ""; // This is the empty string
std::optional<std::string> other_string = "Other content"; // The full string

Just be aware, that to use string interfaces, you will need to get the value of the string with .value() or operator*:

void print_string(const std::string& s);

print_string(*other_string);

This requires you to check that the string is actually valid before calling or you will invoke undefined behaviour.

The answer below is quite theoretical.
In practice usually there's no real need to distinguish between an empty string and a null one and using std::string as is is the best solution. And if you only need to add only the "nullabilty" to your C++ string you can use std::optional as mentioned in the comments and other answer.

Having said that:

In Java a String is a reference type, meaning variables like flag actually hold a reference to the String object (and the reference can be null). An object can have multiple references to it, and when this number becomes zero the object can be automatically destroyed.

If you want to achieve an overall similar behavior in C++, you can use std::shared_ptr holding a std::string:

#include <memory>
#include <string>
//...
std::shared_ptr<std::string> s1 = nullptr;      // null string
std::shared_ptr<std::string> s2 = std::make_shared<std::string>("");    // empty string
std::shared_ptr<std::string> s3 = std::make_shared<std::string>("abs"); // non empty string

On C++ can we expression the string as NULL (nullptr) ?

No you can't . want to expression string as nullptr need string pointer

On C++ can we expression the string as NULL (nullptr) ? if not use pointer .

Maybe std::optional is answer .

My data model is used for Mysql And nlohmann Json .

0. assume select std::optional<string> flag

1. for mysql , you can expression string NULL , flag = nullopt

2. for nlohmann Json , you must to compatible with std::optional

   namespace nlohmann {
     /* https://github.com/nlohmann/json#how-do-i-convert-third-party-types */
     template <typename T>
     struct adl_serializer<std::optional<T>> {
         static void to_json(json& j, const std::optional<T>& opt) {
           if(opt.has_value()) {
               // this will call adl_serializer<T>::to_json which will
               // find the free function to_json in T's namespace!
               j = opt.value();
           } else {
               j = nullptr;
           }
         }
   
         static void from_json(const json& j, std::optional<T>& opt) {
             if (j.is_null()) {
               opt = std::nullopt;
             } else {
               opt = j.get<T>(); // same as above, but with
                                 // adl_serializer<T>::from_json
             }
         }
     };
   }
   

Other things

1. Copy form @wohlstad In Java a String is a reference type, meaning variables like flag actually hold a reference to the String object (and the reference can be null).

My Reference :

1. https://github.com/nlohmann/json/issues/1749
2. https://www.kdab.com/jsonify-with-nlohmann-json/