I understand that the he implicit copy constructor/assignment operator does a member-wise copy of the source object.

Say my class has 1000 members. I want to suppress ONE of the member when doing assignment assignment(and the default value applies), the other 999 members still use the member-wise copy as the implicit assignment operator.

For example:

```
class Foo
{
    std::string s1;
    std::string s2;
    std::string s3;
    ....
    std::string s1000;
};

```

Then we fill object f1 with some values:

```
Foo f1;
f1.s1 = "a";
f1.s2 = "b";
f1.s3 = "c";
...

```

Now we copy assign f1 (source) to f2 (target)

```
Foo f2 = f1;

```

How can I achieve the following result if I want to suppress "s2"?

```
assert(f2.s1 == "a");
assert(f2.s2 == "");        //default value 
assert(f2.s3 == "c");

```

I understand that provide a copy constructor/assignment operator will solve this problem.

```
class Foo
{
    Foo( const Foo& other)
    {
        s1 = other.s1;
        //s2 = other.s2;    //suppress s2
        s3 = other.s3;
        ...
        s1000 = other.s1000;
    };

    Foo& Foo::operator=( const Foo& other)
    {
        s1 = other.s1;
        //s2 = other.s2;    //suppress s2
        s3 = other.s3;
        ...
        s1000 = other.s1000;

        return *this;
    };

    std::string s1;
    std::string s2;
    std::string s3;
    ....
    std::string s1000;
};

```

However, I have 1000 members. I don't want to implement such big functions.

If I implement function like this:

```
class Foo
{
    Foo( const Foo& other)
    {
        *this = other;
        s2 = "";
    };

    Foo& Foo::operator=( const Foo& other)
    {
        *this = other;
        s2 = "";
        return *this;
    };
}

```

Obviously, that's endless recursive.

Here is the only choice for me at the moment, which is:

```
Foo f2 = f1;
f2.s2 = "";

```

However, suppose there are thousands of `Foo f2 = f1;` statements in my project. Finding them all to append one line after them is way too hard.

So, I want the minimum code change to customize the member-wise copy of an object. How can I do this?